Obtener el primer elemento de una enumeración y luego iterar el resto

Tengo un IEnumerable<Task> que describe de manera efectiva cómo obtener una colección de elementos de la caché. El elemento MyObject tiene un mensaje de error y un objeto de éxito. Me gustaría hacer algo como esto:

List<MyObject> fetchAll(IEnumerable<Task<MyObject>> tasks)
{
    var (firstResponse, restOfEnumerable) = await tasks.DoSomethingToGetFirstResonseAndRestOfEnumerableAsync().ConfigureAwait(false);
    if(!firstResponse.IsSuccess)
    {
        return null;
    }

    List<MyObject> ret = new List<MyObject>(firstResponse.Result);
    ret.AddRange(await Task.WhenAll(restOfEnumerable).ConfigureAwait(false));
    return ret;
}

Sé que podría hacer esto llamando a ToList() en el enumerable y haciendo esto:

List<MyObject> fetchAll(List<Task<MyObject>> tasks)
    {
        var firstResponse = await tasks[0].ConfigureAwait(false);
        if (!firstResponse.IsSuccess)
        {
            return null;
        }

        List<MyObject> ret = new List<MyObject>(firstResponse.Result);
        ret.AddRange(await Task.WhenAll(tasks.Skip(1)).ConfigureAwait(false));
        return ret;
    }

pero estoy tratando de no iterar completamente el IEnumerable solo para probar el primer elemento.

Supongo que también podría bajar y obtener el enumerador yo mismo de esta manera:

List<MyObject> fetchAll(IEnumerable<Task<MyObject>> tasks)
{
    var ret = new List<MyObject>();
    using (var enumerator = tasks.GetEnumerator())
    {
        if (enumerator.MoveNext())
        {
            var firstResult = await enumerator.Current.ConfigureAwait(false);
            if (!firstResponse.IsSuccess)
            {
                return null;
            }
            ret.Add(firstResponse.Result);
        }

        List<Task> restOfTasks = new List<Task>();
        while (enumerator.MoveNext())
        {
            restOfTasks.Add(enumerator.Current);
        }

        ret.AddRange(await Task.WhenAll(restOfTasks).ConfigureAwait(false));
    }
}

pero espero que haya algo incorporado que esté pasando por alto.