Ok. So you’re doing this and it does what you want:
transform.Rotate(new Vector3(axis2,axis1,0),Space.World);
You’re rotating the object’s transform around the z axis by axis2 degrees and around the x axis by axis1 degrees in world space according to the Unity documentation. I’m understanding that you want to do the same thing with a quaternion.
In an effort to simplify everything, it seems to me like they’ve made it more complicated. 
The first question is whether a quaternion is even needed? Or more to the point, how do you know the code above doesn’t use a quaternion? They’ve obfuscated the rotation away from you, so you really don’t know how the rotation is actually being performed. It may take those pitch, yaw, roll values and build a quaternion and the transform may be stored as a quaternion under the hood. Without source code, there’s no way to know.
Lol. Actually - after writing that above, I just found that in the documentation “Unity stores rotations as Quaternions internally. To rotate an object, use Transform.Rotate. Use Transform.eulerAngles for setting the rotation as euler angles.”
It looks to me like you can set a Transformation’s rotation amount directly.
You should be able to do this:
//These two are NOT the same even though they look like they are if you are not familiar with quaternion math.
transform.rotation = transform.rotation * Quaternion.Euler(axis2, axis1, 0);
//or
transform.rotation = Quaternion.Euler(axis2, axis1, 0) * transform.rotation;
I believe one should revolve around the world axis and the other around the local axis. I would have to actually test it to make sure it works but I’ve found that the order of operations matters significantly. When you use the *= operator its going to determine which gets applied first. And its my experience that when you take a world matrix and multiply it by a rotation matrix the order in which you perform that rotation will determine whether its done in local space or world space. Transformations are world matrices…usually. In this case, its apparently a quaternion under the hood. But the same applies to quaternions also.
But it looks to me like it doesn’t really change much to use quaternions here since its apparently using quaternions in both cases under the hood. It kind of looks to me like both options do the exact same thing by converting pitch, yaw, and roll into quaternions and then performing a quaternion rotation and then applying the results as a world matrix at draw time (Graphics cards don’t understand what a quaternion is. They only accept matrices and so in the end it will end up being a matrix anyway.)
Where you might see a slight performance advantage would be if you’re storing a value as a quaternion, doing mathematical operations on the quaternion itself, and then applying it as a rotation. Here, I’m not sure there’s any difference at all between using quaternions and using transform.Rotate().
Anyway, try writing the multiplication operation out instead of using the *= operator and try switching which gets multiplied to which. Multiplication combines quaternions, but its not commutative (I had to go look that word up since I’m not a math teacher) like multiplication with numbers; the order in which they are multiplied greatly matters. And you have to write it out in long form if you don’t like the order that *= does it in.
Anyway, see if that helps.
Oh. Also, when you do a rotation away from the origin, you generally have to move the object to the origin, rotate it, and move it back. That may come in to play in this problem or it may not. In the first example, it looked like you were asking Unity to perform the rotation for you and so it may be doing that under the hood without you being aware of it. In the example I gave, it should be a direct rotation which may cause the object to orbit the origin rather than rotating around itself. If it’s a child of another object, that object’s position will be its origin. But whatever its origin is, it will always rotate around its origin. If the object is moved away from its origin, you must move it to the origin, rotate, then move it back where it was unless you want it to orbit rather than rotate.