Create multiple tasks, don't await them, but have them run sequentially

Tasks aren't threads. There's never a good reason to create a task through its constructor and try to "start" it later. A Task is a Promise that something will complete in the future and may not even be executable. For example, Task.Delay uses a timer to signal a TaskCompletionSource.

It's impossible to control execution through Start, again because tasks arent' threads. Start only schedules a task for execution, it doesn't actually run it. There's no guarantee the tasks will run in the order they were scheduled.

await doesn't execute a task either, it awaits an already active task to complete, without blocking the calling thread. You don't need to await a task to make it execute. You only need to await it when you want to get its results, or wait for it to finish.

As for the question itself, it's unclear what the problem is. If the question is how to execute some async functions in sequence without awaiting the entire sequence, the easiest way would be to put them in their own async method, store its task in a variable and await it when needed :

async Task GetAnImageAsync()
{
    //Load a URL from DB using Dapper
    var url=await connection.QueryFirstOrDefault<string>("select top 1 URLs from Pictures");
    //Get the image
    var image=await client.GetByteArrayAsync(url);
    //Save it
    await File.WriteAllBytesAsync("blah.jpg",image);
}

...

async Task DoSomethingElse()
{
    var imageTask=GetAnImageAsync();
    //Do some other work
    ...
    //Only await at the end
    await imageTask();
}

You'll hear frequently that using the Task constructor is not recommended, and it's a wise advice. It's easier to create a Func<Task>, and invoke it when you want to start the task, and it's also safer. The Task constructor has the same hidden gotchas with the ContinueWith method: it doesn't understand async delegates, and it requires to specify explicitly the scheduler when you start it. But if you know positively that the Task constructor is the best tool for your problem, here is how you can use it:

Task<Task> taskTask1 = new Task<Task>(async () =>
{
    Console.WriteLine("Task1 Start");
    await Task.Delay(5000);
    Console.WriteLine("Task1 STOP");
});

Task<Task> taskTask2 = new Task<Task>(async () =>
{
    Console.WriteLine("Task2 Start");
    await Task.Delay(5000);
    Console.WriteLine("Task2 STOP");
});

Task taskParent = Task.Run(async () =>
{
    Console.WriteLine("starting 1");
    taskTask1.Start(TaskScheduler.Default);
    await taskTask1.Unwrap();
    Console.WriteLine("starting 2");
    taskTask2.Start(TaskScheduler.Default);
    await taskTask2.Unwrap();
});

Console.WriteLine("BEGIN await parent");
await taskParent;
Console.WriteLine("END await parent");

Output:

BEGIN await parent
starting 1
Task1 Start
Task1 STOP
starting 2
Task2 Start
Task2 STOP
END await parent

Notice that you don't need to Unwrap the Task.Run, because this method understands async delegates, and does the unwrapping automatically for you.

Notice also the TaskScheduler.Default passed as argument to the Start method. Not specifying the scheduler makes your code depended on the ambient TaskScheduler.Current, and might generate warnings in the presence of the CA2008 analyzer.

Basically in c# a task created is always running, therefore if you create task, and not awaiting it, then it will be running in separate thread most likely. Take a look at: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/async/

To archive sequential execution you either have to do a kind of scheduler for them or implement sequence on some sort of locking mechanism.

Continue with is the easiest method to guarantee that.

Given that all task constructors accept Action or variants of thereof, doing

var task1 = new Task(async ()=>
{
    Console.WriteLine("Task1 Start");
    await Task.Delay(5000);
    Console.WriteLine("Task1 STOP");
});

task1.Start();
await task1;

is not dissimilar to doing

void EntryPoint()
{
    CallAsync();
}

async void CallAsync()
{
    Console.WriteLine("Task1 Start");
    await Task.Delay(5000);
    Console.WriteLine("Task1 STOP");
}

The CallAsync from above will run until first suspension (await Task.Delay(5000)) upon which it registers a Timer callback and returns to the caller which promptly returns, completely unaware of any async semantics.

If the application is still alive by the time the Timer under Task.Delay fires, it will run the continuation based on current TaskScheduler and SynchronizationContext as usual, writing Task1 STOP to the console.

If you need to run tasks sequentially without awaiting them, either use ContinueWith or implement a custom TaskScheduler to do this for you.

Or even better, as suggested by @Panagiotis Kanavos, create a stand-alone async method which runs the sequence of tasks and await its result:

async Task PerformThingsAsync()
{
    var task = RunMyTasksAsync();

    // Do things

    await task;
}

async Task RunTasksAsync()
{
    await RunFistTaskAsync();
    await RunSecondTaskAsync();
    // ...
}