Multithreading fstream

I'm trying to write simulaniously into a file using fstreams on multiple threads. But for some reason I always get the fastest results when only using one thread. Does anyone know why?

#pragma once

#include <atomic>
#include <thread>

#include "TestWriter.h"
#include "../ut_General/Random.hpp"
#include "../ut_General/Test.hpp"


template <uintmax_t ThreadCount>
class TestWriterMultiThreadManualChunkBuffer : public TestWriter {
public:
    TestWriterMultiThreadManualChunkBuffer() = default;

    virtual ~TestWriterMultiThreadManualChunkBuffer() = default;
    virtual void WriteToFile(std::filesystem::path path, uintmax_t fileSize, uintmax_t chunkSize, char* data) {
        std::error_code err;
        std::filesystem::resize_file(path, fileSize, err);
        if (err) {
            std::cout << err.message() << std::endl;
            return;
        }

        std::thread* threads[ThreadCount];
        for (int x = 0; x < ThreadCount; x++) {
            threads[x] = new std::thread(&WriteThread, path, fileSize, chunkSize, data, this);
        }

        for (int x = 0; x < ThreadCount; x++) {
            threads[x]->join();
            delete threads[x];
        }
    }
    virtual std::string ToString() {
        return "Multi Thread <" + std::to_string(ThreadCount) + "> : Manual Chunk Buffer";
    }

private:
    static void WriteThread(std::filesystem::path path, uintmax_t fileSize, uintmax_t chunkSize, char* data, TestWriterMultiThreadManualChunkBuffer* that) {
        std::fstream stream(path, std::fstream::out | std::fstream::in | std::fstream::binary);

        while (true) {
            uintmax_t c = that->counter.fetch_add(1);
            if (c >= fileSize / chunkSize) {
                return;
            }
            stream.write(data + c * chunkSize, chunkSize);
        }
    }

    std::atomic<uintmax_t> counter = 0;
};