C/C++ - Avvio programma all'accesso di Windows

Ho sviluppato un programma in C++ alla quale ho aggiunto la possibilità di farlo partire all'avvio di Windows.
Il problema è che se lo faccio partire manualmente funziona bene mentre all'avvio appare e scompare immediatamente(nel task manager non c'è nemmeno il processo). Premetto che ho fatto anche altre prove come ad esempio metterlo in Esecuzione Automatica ma accade sempre la stessa cosa

Ma questo programma cosa fa?

In pratica è una rudimentale chat su console formata da un eseguibile per aggiornare e un eseguibile per la chat.
All'avvio dovrebbe partire l'updater che controlla se ci sono aggiornamenti e poi fa partire la chat.
I due eseguibili sono applicazioni console che ho compilato con gnu g++ con l'aiuto delle librerie cURL per inviare e ricevere attraverso http.

Il fatto è che non mi riesco a spiegare che cosa accade quando lo faccio partire in avvio automatico perché se lo apro io funziona

Probabilmente il primo eseguibile non trova il secondo (quando è in esecuzione automatica).

Mostraci il codice del primo eseguibile ...

#include <string>
#include <fstream>
#include <curl/curl.h>

#define URL_BASE "http://localhost/"
#define URL_CHECK URL_BASE "chat/version.php"
#define URL_UPDATE   URL_BASE "chat/chat.exe"
#define OUTPUT_FILE "chat.exe"
#define NO_INTERNET "NOINTERNETCONNECTION"

using namespace std;

string currentversion;

static size_t WriteCallback(void *contents, size_t size, size_t nmemb, void *userp)
{
	((std::string*)userp)->append((char*)contents, size * nmemb);
	return size * nmemb;
}

string getData(char *URL){
	CURL *curl;
	CURLcode res;
	std::string readBuffer;

	curl = curl_easy_init();
	if(curl) {
		curl_easy_setopt(curl, CURLOPT_URL, URL);
		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
		curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
		res = curl_easy_perform(curl);
		curl_easy_cleanup(curl);
		if (res != CURLE_OK){
			return NO_INTERNET;
		}
		return readBuffer;
	}
	return "";
}

int CheckUpdate(void){
	fstream file;
	file.open("version.txt");

	string localversion;
	file >> localversion;

	file.close();

	currentversion = getData(URL_CHECK);
	
	if (currentversion != NO_INTERNET && currentversion != localversion){
		return 1;
	}
	return 0;
}

void Update(void){
	string Buffer = getData(URL_UPDATE);
	if(Buffer != NO_INTERNET){
		ofstream file(OUTPUT_FILE, fstream::out | fstream::trunc);
		file << Buffer << std::endl;
		file.close();
		file.open("version.txt");
		file << currentversion;
		file.close();
	}
}

void Start(char *Application){
	STARTUPINFO         siStartupInfo;
	PROCESS_INFORMATION piProcessInfo;

	memset(&siStartupInfo, 0, sizeof(siStartupInfo));
	memset(&piProcessInfo, 0, sizeof(piProcessInfo));

	siStartupInfo.cb = sizeof(siStartupInfo);

    if(CreateProcess(Application,        //eseguibile
                     "",                 //Args
                     0,
                     0,
                     FALSE,
                     CREATE_DEFAULT_ERROR_MODE,
                     0,
                     0,                              // Working directory
                     &siStartupInfo,
                     &piProcessInfo) == FALSE);
}

int main(void){
	if (CheckUpdate() == 1){
		Update();
	}
	Start("chat.exe");

	return 0;
}

Solo per provare il mio dubbio, ricompila indicando la directory assoluta

Start("C:\cartella1\cartella2\chat.exe";

Si, serviva la directory assoluta! grazie per la dritta
Per curiosità, perché gli programmi in esecuzione automatica non vengono eseguiti nelle loro rispettive directory?

Ma tu come avevi organizzato i due eseguibili? Dove stavano?