Why Does ZipArchiveEntry.Open().ReadAsync() Return Fewer Bytes Than Read()?

I am experiencing a performance discrepancy when extracting files from a 400 MB archive. Using the synchronous version of Read/Write yields much faster results compared to the asynchronous version. Specifically, when I increase the chunk size to 1 MB, the synchronous Stream.Read reads the full 1 MB per call, while ReadAsync only returns around 15 kB per call, which significantly slows down the overall process.

Below is the synchronous version:

CSHARPCopied
private static async Task ExtractFilesAsync(this ZipArchive archive, string destination, IProgress<int> progress = null)
{
    await Task.Run(() =>
    {
        long bytesWritten = 0;
        long totalBytes = archive.GetUncompressedSize();
        int percent = 0;
        foreach (ZipArchiveEntry entry in archive.Entries)
        {
            if (!entry.IsDirectory())
            {
                string fullPath = Path.Combine(destination, entry.FullName);

                using (FileStream writeStream = File.OpenWrite(fullPath))
                {
                    using (Stream readStream = entry.Open())
                    {
                        int chunkSize = 1024;
                        byte[] buffer = new byte[chunkSize];

                        while (true)
                        {
                            int bytesRead = readStream.Read(buffer, 0, chunkSize);
                            if (bytesRead == 0)
                            {
                                break;
                            }
                            writeStream.Write(buffer, 0, bytesRead);
                            bytesWritten += bytesRead;
                            int newPercent = (int)(bytesWritten / (double)totalBytes * 100.0);
                            if (newPercent > percent)
                            {
                                percent = newPercent;
                                progress?.Report(percent);
                                Trace.WriteLine($"{percent}");
                            }
                        }
                    }
                }
            }
        }
    });
}

And here is the asynchronous version:

CSHARPCopied
private static async Task ExtractFilesAsync(this ZipArchive archive, string destination, IProgress<int> progress = null)
{
        long bytesWritten = 0;
        long totalBytes = archive.GetUncompressedSize();
        int percent = 0;
        foreach (ZipArchiveEntry entry in archive.Entries)
        {
            if (!entry.IsDirectory())
            {
                string fullPath = Path.Combine(destination, entry.FullName);

                using (FileStream writeStream = File.OpenWrite(fullPath))
                {
                    using (Stream readStream = entry.Open())
                    {
                        int chunkSize = 1024;
                        byte[] buffer = new byte[chunkSize];

                        while (true)
                        {
                            int bytesRead = await readStream.ReadAsync(buffer, 0, chunkSize);
                            if (bytesRead == 0)
                            {
                                break;
                            }
                            await writeStream.WriteAsync(buffer, 0, bytesRead);
                            bytesWritten += bytesRead;
                            int newPercent = (int)(bytesWritten / (double)totalBytes * 100.0);
                            if (newPercent > percent)
                            {
                                percent = newPercent;
                                progress?.Report(percent);
                                Trace.WriteLine($"{percent}");
                            }
                        }
                    }
                }
            }
        }
}

The key question is: Why does the async version, specifically the ReadAsync call on the stream from ZipArchiveEntry.Open(), perform so much slower by reading smaller byte amounts per request?