You can’t expect absolute precision, but the problem in your case is actually the order the rotations are applied. When you use Euler angles (as Transform.Rotate does), if you consider them to be rotations around local axes (the default), it’s equivalent to performing a Y axis rotation, then an X axis rotation, then a Z axis rotation. (The documentation lists them in the opposite order, but that’s only correct for the non-default case where you’re performing each rotation about the world axes, or some other frame that doesn’t rotate with the object.)

So this, in your code:

```
transform.Rotate( new Vector3(1,1,0));
```

is the same as this (plus rounding error):

```
transform.Rotate( new Vector3(0,1,0));
transform.Rotate( new Vector3(1,0,0));
```

and in order to invert it, you have to apply the backwards rotations in the opposite order, like this:

```
transform.Rotate( new Vector3(-1,0,0));
transform.Rotate( new Vector3(0,-1,0));
```

However, your second line of code is equivalent to these two lines but the other way around, and that’s why you don’t end up with the orientation you expect. It will be much more obvious with larger angles, too.

So one solution is to split the axis rotations up, at least when you’re doing the backwards rotation, and apply them individually in the correct order. Another is to calculate the quaternion you’re applying separately from applying it, remember it, and calculate its inverse before applying that. This is quite straightforward:

```
myRotationDelta = Quaternion.Euler(1, 1, 0);
transform.localRotation *= myRotationDelta;
... later ...
transform.localRotation *= Quaternion.Inverse(myRotationDelta);
```

I don’t know whether this helps much with your problem though. If somebody changes the position or rotation while you have it modified, and you then try to undo your modification, you won’t generally end up with the same result you’d get if the external rotation was applied without your rotation being there at all.

Presumably you only want to apply the offset for rendering? If so, maybe you can apply the rotation in LateUpdate (perhaps using script execution order to ensure your script runs last), and revert your rotation at the point of WaitForEndOfFrame (which you’ll have to do in a coroutine).