I found another simple tonemapper, it's called "ACES Filmic Tonemapping"... The algorithm goes like this:

float3 ACESFilm( float3 x )
{
float a = 2.51f;
float b = 0.03f;
float c = 2.43f;
float d = 0.59f;
float e = 0.14f;
return saturate((x * (a * x + b)) / (x * (c * x + d) + e));
}

The reversed algorithm would look something like this:

float3 i_ACESFilm( float3 x )
{
float a = 2.51f;
float b = 0.03f;
float c = 2.43f;
float d = 0.59f;
float e = 0.14f;
//Might be totally wrong because I have no idea what I'm doing XD
return saturate((x / (a / x - b)) * max(x / (c / x - d) - e, 0.001));
}

This is the default tonemapper used in Unreal Engine 4 (hint, hint)... It reminds me of Marty's Haarm Peter modification, but slightly simpler.

EDIT: after testing this myself, it seems to work well, even on a Unity game

Here is a screenshot of it wigging out in an amazingly beautiful way XD

Here is a gif of it working correctly (Ignore the overpowering intensity, I did that intentionally to make the algorithm more apparent):

Here is my code. No additive tonemapping is required, btw:

float3 i_ACESFilm(float4 vpos : SV_Position, float2 texcoord : TexCoord) : SV_Target
{
float3 x = blur(ReShade::BackBuffer, texcoord, 2.0 * fBloom_Radius);
float a = 2.51f / fBloom_Threshold;
float b = 0.03f - fBloom_Threshold;
float c = 2.43f / fBloom_Threshold;
float d = 0.59f - fBloom_Threshold;
float e = 0.14f - fBloom_Threshold;
return saturate((x / (a / x - b)) * max(x / (c / x - d) - e, 0.001));
}

Then I call the return in the first blur pass (aka thresholding pass) like this:

And no, this does not apply the tonemapping to the final image. And yes, I removed the HDRPass thing I used to have!

On/Off comparison of the final image: