How to change the stopwatch settings to get a “clean” counting time?
Using an external program to measure the execution time for each thread, while taking CPU scheduling, context switches, interrupts etc. into account would require an advanced profiling tool and an API for the operating system that allows to perform such detailed measurements. This is not something that can be covered in a single answer and is off-topic for Blender's StackExchange.

I think the whole premise of your question is going in a wrong direction though, since the mentioned render engines use different conceptual approaches for the rendering. Comparing the render time of LuxCore and Cycles is like comparing the speed of a race car with a cruise ship. While they both transport people from one place to another, they serve a different purpose and therefore function differently. For instance LuxCore is able to simulate certain physical properties of light, like dispersion through a prism, which Cycles cannot do. Therefore Cycles would render such as scene much faster, but the results would be less physically accurate. In conclusion the execution time is not a helpful metric for this comparison.

That being said you can get precise time measurements, compared to manually operating a stopwatch, by using a simple Python script. This does not measure the execution time per thread though.

The script gets all the available render engines in Blender and renders the scene with them. The rendering is repeated measurements_per_engine times to get multiple data points, since the systems load will impact the measurements. In the end some basics statistics are calculated and printed to the console. The console can be toggled through Window > Toggle System Console if you're using Windows, otherwise you'd have to start Blender from the command line. Alternatively you could modify the script and write the measurements to a file. Be aware that the script currently freezes the UI, but since you're trying to benchmark the render engines you shouldn't be using Blender during the rendering anyway since this would impact the timings.

import bpy
import time
import statistics


render_engines = ['BLENDER_WORKBENCH', 'BLENDER_EEVEE']

# Get the render engines registered through Python
registered_engine_types = bpy.types.RenderEngine.__subclasses__()

for engine_type in registered_engine_types:
    render_engines.append(engine_type.bl_idname)

# The number of renders per engine for which we measure the render time
measurements_per_engine = 2
render_times = {}

for render_engine in render_engines:
    render_times[render_engine] = []

for i in range(measurements_per_engine):
    for render_engine in render_engines:
        bpy.context.scene.render.engine = render_engine
        start = time.perf_counter()
        bpy.ops.render.render()
        end = time.perf_counter()
        render_times[render_engine].append(end - start)

for render_engine in render_engines:
    timings = render_times[render_engine]
    min_time = min(timings)
    max_time = max(timings)
    mean_time = statistics.mean(timings)
    stdev_time = statistics.stdev(timings)
    print(f'{render_engine}\n min: {min_time}s\n max: {max_time}s\n mean: {mean_time}s\n stdev: {stdev_time}s\n')