Camera rotation problem: Keeps reseting to initial position

So, I was following this tutorial video on making the camera orbit the character, and I wrote down the code like in the video, but for some reason whenever I try to rotate the camera, it resets to the initial rotation. I have no idea how to solve this. Zooming works fine though.

My problem is exactly like this previous problem, but the code used by that other asker is completely different and I couldn't find a way to translate the solution to my code.

All I have deduced is that the problem is on either MoveToTarget() or LookAtTarget(). Any idea of what I should do? Thanks.

 public class OrbitalCameraController : MonoBehaviour {
 
     public Transform target;
 
     [System.Serializable]
     public class PositionSettings
     {
         public Vector3 targetPosOffset = new Vector3(0, 3.4f, 0);
         public float lookSmooth = 100f;
         public float distanceFromTarget = -8;
         public float zoomSmooth = 100;
         public float maxZoom = -2;
         public float minZoom = -15;
     }
 
     [System.Serializable]
     public class OrbitSettings
     {
         public float xRotation = -20;
         public float yRotation = -180;
         public float maxXRotation = 25;
         public float minXRotation = -85;
         public float vOrbitSmooth = 150;
         public float hOrbitSmooth = 150;
     }
 
     [System.Serializable]
     public class InputSettings
     {
         public string ORBIT_HORIZONTAL_SNAP = "OrbitHorizontalSnap";
         public string ORBIT_HORIZONTAL = "OrbitHorizontal";
         public string ORBIT_VERTICAL = "OrbitVertical";
         public string ZOOM = "Mouse ScrollWheel";
     }
 
     public PositionSettings position = new PositionSettings();
     public OrbitSettings orbit = new OrbitSettings();
     public InputSettings input = new InputSettings();
         
     Vector3 targetPos = Vector3.zero;
     Vector3 destination = Vector3.zero;
     PlayerController charController;
     float vOrbitInput, hOrbitInput, zoomInput, hOrbitSnapInput;
 
     // Use this for initialization
     void Start () {
         SetCameraTarget(target);
 
         MoveToTarget();
     }
     
     public void SetCameraTarget(Transform t)
     {
         target = t;
 
         if (target !=  null)
         {
             if(target.GetComponent<PlayerController>())
             {
                 charController = target.GetComponent<PlayerController>();
             } 
             else
             {
                 Debug.LogError("The camera's target needs a character controller.");
             }
         }
         else
         {
             Debug.LogError("Your camera needs a target.");
         }
     }
 
     void GetInput()
     {
         vOrbitInput = Input.GetAxisRaw(input.ORBIT_VERTICAL);
         hOrbitInput = Input.GetAxisRaw(input.ORBIT_HORIZONTAL);
         hOrbitSnapInput = Input.GetAxisRaw(input.ORBIT_HORIZONTAL_SNAP);
         zoomInput = Input.GetAxisRaw(input.ZOOM);
     }
 
     // Update is called once per frame
     void Update()
     {
         GetInput();
         OrbitTarget();
         ZoomInOnTarget();
     }
 
     void LateUpdate()
     {
         //move
         MoveToTarget();
         //rotating
         LookAtTarget();
     }
 
     void MoveToTarget()
     {
         targetPos = target.position + position.targetPosOffset;
         destination = Quaternion.Euler(orbit.xRotation, orbit.yRotation + target.eulerAngles.y, 0) * (- Vector3.forward) * position.distanceFromTarget;
         destination += targetPos;
         transform.position = destination;
     }
 
     void LookAtTarget()
     {
         Quaternion targetRotation = Quaternion.LookRotation(targetPos - transform.position);
         transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, position.lookSmooth * Time.deltaTime);
     }
 
     void OrbitTarget()
     {
         if (hOrbitSnapInput > 0)
         {
             orbit.yRotation = -180;
         }
 
         orbit.xRotation = -vOrbitInput * orbit.vOrbitSmooth * Time.deltaTime;
         orbit.yRotation = -hOrbitInput * orbit.hOrbitSmooth * Time.deltaTime;
 
         if (orbit.xRotation > orbit.maxXRotation)
         {
             orbit.xRotation = orbit.maxXRotation;
         }
 
         if (orbit.xRotation < orbit.minXRotation)
         {
             orbit.xRotation = orbit.minXRotation;
         }
     }
 
     void ZoomInOnTarget()
     {
         position.distanceFromTarget += zoomInput * position.zoomSmooth * Time.deltaTime;
 
         if (position.distanceFromTarget > position.maxZoom)
         {
             position.distanceFromTarget = position.maxZoom;
         }
 
         if (position.distanceFromTarget < position.minZoom)
         {
             position.distanceFromTarget = position.minZoom;
         }
     }
 }