Here is a stripped version of my code. The 2 functions fadeTo and fadeTo2 are working well without WiFi.

When I WiFi.begin() is enabled the flickering begins.

#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <FastLED.h>

IPAddress ip(192, 168, 0, 139);
/*
Gateway
Subnet
DNS
*/

bool updateFadeColors1 = false;
bool updateFadeColors2 = false;

#define NUM_LEDS 60
#define DATA_PIN 2              // 2 er D4 på NodeMCU

byte fadeRed = 255;
byte fadeGreen = 0;
byte fadeBlue = 0;
byte fadeRed2 = 0;
byte fadeGreen2 = 255;
byte fadeBlue2 = 0;
byte fadeAmount = 1;
byte fadeDelay = 100;

WiFiClient espClient;
PubSubClient client(espClient);

void setup() {
  Serial.begin(115200);
  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip ); //Typical8mmPixel); // ( TypicalSMD5050 );
  
  setup_wifi();
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback);
 
  if (!client.connected()) {
    reconnect();
  }
  
  setBright(brightness);
  setAll(0,0,255);
  delay(3000);
}

/********************************** START SETUP WIFI*****************************************/
void setup_wifi() {
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);

  WiFi.hostname(deviceName);
  WiFi.setSleepMode(WIFI_LIGHT_SLEEP);
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  WiFi.config(ip, gateway, subnet, dns);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }

  if (WiFi.status() != WL_CONNECTED) {
    delay(1);
    Serial.print("WIFI Disconnected. Attempting reconnection.");
    setup_wifi();
    return;
  }

  client.loop();
  
  // Set true in callback split function
  if (updateFadeColors1 == true) {
    fadeTo(fadeRed, fadeGreen, fadeBlue, fadeDelay, fadeAmount);
  } else if (updateFadeColors2 == true) {
    fadeTo2(fadeRed, fadeGreen, fadeBlue, fadeRed2, fadeGreen2, fadeBlue2, fadeDelay, fadeAmount);
  }
}

void reconnect() {
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    
    if (client.connect(deviceName, mqtt_username, mqtt_password)) {
      Serial.println("connected");
      di = "modelbane/neopixels/" + neoName;
      di.toCharArray(diSubscribe, 60);
      
      client.subscribe(diSubscribe);
      delay(5000);
    }
  }
}
void callback(char* topic, byte* payload, unsigned int length) {
  // Split received mqtt msg
}

// Helper function that blends one uint8_t toward another by a given amount
void nblendU8TowardU8( uint8_t& cur, const uint8_t target, uint8_t amount)
{
  if( cur == target) return;
  
  if( cur < target ) {
    uint8_t delta = target - cur;
    delta = scale8_video( delta, amount);
    cur += delta;
  } else {
    uint8_t delta = cur - target;
    delta = scale8_video( delta, amount);
    cur -= delta;
  }
}

CRGB fadeOneColor( CRGB& cur, const CRGB& target, uint8_t amount)
{
  nblendU8TowardU8( cur.red,   target.red,   amount);
  nblendU8TowardU8( cur.green, target.green, amount);
  nblendU8TowardU8( cur.blue,  target.blue,  amount);
  return cur;
}

void fadeTowardColor( CRGB* L, uint16_t N, const CRGB& bgColor, uint8_t fadeAmount)
{
  fadeOneColor( L, bgColor, fadeAmount); // first LED - calc new color
  if ((bgColor == L)) {
    updateFadeColors1 = false;
  }

  for( uint16_t i = 0; i < N; i++) {
     L = L; // copy color from first LED
  }
}

void fadeTowardColor2( CRGB* L, uint16_t N, const CRGB& bgColor, const CRGB& bgColor2, uint8_t fadeAmount)
{
  fadeOneColor( L, bgColor, fadeAmount); // Calc new color first LED
  fadeOneColor( L, bgColor2, fadeAmount); // and second LED

  if ((bgColor == L) && (bgColor2 == L)) {
    updateFadeColors2 = false;
  }
  
  for( uint16_t i = 0; i < N; i++) {
    if ((i % 2) == 0) {
      L = L;  // copy 1st LED color
    } else {
      L = L; // copy seconde LED color
    }
  } 
}

void fadeTo(byte toRed, byte toGreen, byte toBlue, int fadeDelay, byte fadeAmount) {       //byte red, byte green, byte blue, byte toRed, byte toGreen, byte toBlue, int fadeDelay, byte fadeAmount) {
  // Syntax: toRed, toGreen, toBlue, fade delay, how much to fade)
    
  CRGB bgColor(toRed, toGreen , toBlue);
  fadeTowardColor( leds, NUM_LEDS, bgColor, fadeAmount);

  FastLED.show();
  FastLED.delay(fadeDelay);  
}

void fadeTo2(byte toRed, byte toGreen, byte toBlue, byte toRed2, byte toGreen2, byte toBlue2, int fadeDelay, byte fadeAmount) {       //byte red, byte green, byte blue, byte toRed, byte toGreen, byte toBlue, int fadeDelay, byte fadeAmount) {
  // Syntax: toRed, toGreen, toBlue, toRed2, toGreen2, toBlue2, fade delay, how much to fade)
    
  CRGB bgColor(toRed, toGreen , toBlue);
  CRGB bgColor2(toRed2, toGreen2, toBlue2);
  fadeTowardColor2( leds, NUM_LEDS, bgColor, bgColor2, fadeAmount);

  FastLED.show();
  FastLED.delay(fadeDelay);  
}

Kind-a odd though ...
I have a very large sketch with a lot of effects on it, which I control over WiFi.
I run that sketch on a ESP8266, just like your Wemos D1, yet not a single effect flickers.

Can you post the bare minimum code with an effect that flickers and WiFi enabled?
My gut tells me that something is triggering an interrupt - just cannot find anything in the code sniplets you have posted before.

Really not having tested any of this, maybe replace WIFI_NONE_SLEEP with WIFI_LIGHT_SLEEP - just to see what happens. Wifi should remain connected, but I would assume the polling of WiFi is brought down a notch. (I could be totally guessing this wrong of course - but testing won't hurt.

WiFi.setSleepMode(WIFI_LIGHT_SLEEP); 

 Let us know if that made a difference. 😊 

void setup_wifi() {
  WiFi.hostname(deviceName);
  WiFi.setSleepMode(WIFI_NONE_SLEEP);
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  WiFi.config(ip, gateway, subnet, dns);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

If none or only one can be true, then maybe rewrite this ...

  if (updateFadeColors1 == true) {
    fadeTo(fadeRed, fadeGreen, fadeBlue, fadeDelay, fadeAmount);
  }

  if (updateFadeColors2 == true) {
    fadeTo2(fadeRed, fadeGreen, fadeBlue, fadeRed2, fadeGreen2, fadeBlue2, fadeDelay, fadeAmount);
  }

... to a more correct;

  if (updateFadeColors1 == true) {
    fadeTo(fadeRed, fadeGreen, fadeBlue, fadeDelay, fadeAmount);
  } else if (updateFadeColors2 == true) {
    fadeTo2(fadeRed, fadeGreen, fadeBlue, fadeRed2, fadeGreen2, fadeBlue2, fadeDelay, fadeAmount);
  }

(Ditto for the other if-then loop)

It will not fix any problems, its just more correct unless both can be true at the same time of course.

    if (msg.startsWith("F1C")) {       
      splitNeoMsgFade1Color(msg);
    } else if (msg.startsWith("F2C")) {
      splitNeoMsgFade2Color(msg);
    }

void splitNeoMsgFade1Color(String Val)
{
  if (Val.length() > 0) {
    // ************* Split function *************
    // Syntax for sending : "red, green, blue, brightness, fade delay, fade amount" (255,0,0,64,100,5)    
    Val.replace("F1C","");
    
    int idxRed = Val.indexOf(',');
    int idxGreen = Val.indexOf(',', idxRed + 1);
    int idxBlue = Val.indexOf(',', idxGreen + 1);
    int idxBright = Val.indexOf(',', idxBlue + 1);
    int idxFadeDelay = Val.indexOf(',', idxBright +1);
    int idxFadeAmount = Val.indexOf(',', idxFadeDelay + 1);
    
    String r = Val.substring(0, idxRed); // Start, længde
    String g = Val.substring(idxRed + 1, idxGreen);
    String b = Val.substring(idxGreen + 1, idxBlue);
    String bright = Val.substring(idxBlue + 1, idxBright);
    String fDelay = Val.substring(idxBright + 1, idxFadeDelay);
    String fAmount = Val.substring(idxFadeDelay + 1, idxFadeAmount);
    
    fadeRed = r.toInt();
    fadeGreen = g.toInt();
    fadeBlue = b.toInt();
    brightness = bright.toInt();
    fadeDelay = fDelay.toInt();
    fadeAmount = fAmount.toInt();
    
    updateFadeColors1 = true;
    brigtnessUpdated = false;
    Val = "";
  }

As you can see in the loop only if updateFadeColors1 or updateFadeColors2 is true the fade should begin.

When the fade is done the updateFadeColors1 /  updateFadeColors2 should be set false

I hope this helps to clarify the code.

As for time, and this happens to all of us;
The biggest issue is how much time it takes to read and decipher source codes that has been posted. 
Besides that, sometimes the question or explanation is not entirely clear to me. 😜 
(same goes for me as well when I post a question myself haha)

Sending the entire project is probably not going to help, in fact it will makes it even harder to go through and find the details.

Coming back to your code, I'm not sure what is going on in your void loop().

This part:

void loop() {
  if (update1Color == true) {
    setBright(brightness);
    setAll(colorRed, colorGreen, colorBlue);
  }
  if (update2Color == true) {
    setBright(brightness);
    set2Color(colorRed, colorGreen, colorBlue, colorRed2, colorGreen2, colorBlue2);
  }
  if (updateFadeColors1 == true) {
    fadeTo(fadeRed, fadeGreen, fadeBlue, fadeDelay, fadeAmount);
  }

  if (updateFadeColors2 == true) {
    fadeTo2(fadeRed, fadeGreen, fadeBlue, fadeRed2, fadeGreen2, fadeBlue2, fadeDelay, fadeAmount);
  }
  
  // 1 farve
  if ((leds.r == fadeRed) && (leds.g == fadeGreen) && (leds.b == fadeBlue)) {
    updateFadeColors1 = false;
  }
  
  // 2 farver
  if ((leds.r == fadeRed) && (leds.g == fadeGreen) && (leds.b == fadeBlue) && (leds.r == fadeRed2) && (leds.g == fadeGreen2) && (leds.b == fadeBlue2)) {
    updateFadeColors2 = false;
  }
}

Where are update1Color and update2Color set? Are they always true? Both of them?
Or are they mutual exclusive (I would guess so?)?
How does that correlate with updateFadeColors1 and 2? 

Maybe we can look at that and get that structured a little better? Maybe one call interferes with the other?

I think the flickering may be caused by the part

if (updateFadeColors2 == true) {
    fadeTo2(fadeRed, fadeGreen, fadeBlue, fadeRed2, fadeGreen2, fadeBlue2, fadeDelay, fadeAmount);
  }

Even when finished fading the fadeTo2 continues to start.

I am not sure where to set the updateFadeColors2 to false in order to stop the fadeTo2

Maybe if possible, I could send you the whole Wemos project (about 20 Kb)

By the way I am also using WiFi and OTA in my project

Not sure why it would flicker, but I can image there is room for improvement to speed up things.

A few ideas ...

To reduce confusion when reading code maybe it is better we change the name of this functions.
The original fade-to-color developer used the same names as the other function, which is not incorrect, but I found this to be confusing at times when reading code.

So let's change this function

CRGB fadeTowardColor( CRGB& cur, const CRGB& target, uint8_t amount)
{
  nblendU8TowardU8( cur.red,   target.red,   amount);
  nblendU8TowardU8( cur.green, target.green, amount);
  nblendU8TowardU8( cur.blue,  target.blue,  amount);
  return cur;
}

to maybe this (or whatever name you prefer):

CRGB fadeOneColor( CRGB& cur, const CRGB& target, uint8_t amount)
{
  nblendU8TowardU8( cur.red,   target.red,   amount);
  nblendU8TowardU8( cur.green, target.green, amount);
  nblendU8TowardU8( cur.blue,  target.blue,  amount);
  return cur;
}

You will have to update these two functions (fadeTowardColor and fadeTowardColor2) to this, so it uses the new name:

// Fade an entire array of CRGBs toward a given background color by a given amount
// This function modifies the pixel array in place.
void fadeTowardColor( CRGB* L, uint16_t N, const CRGB& bgColor, uint8_t fadeAmount)
{
  for( uint16_t i = 0; i < N; i++) {
    fadeOneColor( L, bgColor, fadeAmount);
  }
}

void fadeTowardColor2( CRGB* L, uint16_t N, const CRGB& bgColor, const CRGB& bgColor2, uint8_t fadeAmount)
{
  for( uint16_t i = 0; i < N; i++) {
    if ((i % 2) == 0) {
      fadeOneColor( L, bgColor, fadeAmount);
    } else {
      fadeOneColor( L, bgColor2, fadeAmount);
    }
  }
}

Next, the entire strip is either one or two colors, so instead of recalculating the new color for each individual LED, we could calculate the new color only one time and copy it to the other LEDs. This would potentially be significantly faster.

Maybe something like this (calculate once, and copy it for all LEDs);

// Fade an entire array of CRGBs toward a given background color by a given amount
// This function modifies the pixel array in place.
void fadeTowardColor( CRGB* L, uint16_t N, const CRGB& bgColor, uint8_t fadeAmount)
{
  fadeOneColor( L, bgColor, fadeAmount); // first LED - calc new color

  for( uint16_t i = 0; i < N; i++) {
     L = L; // copy color from first LED
  }
}

void fadeTowardColor2( CRGB* L, uint16_t N, const CRGB& bgColor, const CRGB& bgColor2, uint8_t fadeAmount)
{
  fadeOneColor( L, bgColor, fadeAmount); // Calc new color first LED
  fadeOneColor( L, bgColor, fadeAmount); // and second LED

  for( uint16_t i = 0; i < N; i++) {
    if ((i % 2) == 0) {
      L = L;  // copy 1st LED color
    } else {
      L = L; // copy seconde LED color
    }
  }
}

Next, I'd strip your code (in a copy of course) to just the 2 color fade related code ... just to make sure we get that to work first.
So remove as much as you can, just to stick to the barebones 2 color fade.