Motorbike WheelCollider Physics freaks out

So i have 3 scripts named MotorbikeController MotorBikePlayerFeedbackController MotorbikeVisualController that all work in tandem with each other to control a motorbike and i had this working previously but i changed where the wheels were parented as when leaning it caused the bike to freek out and this worked however the wheel colliders were not in the right place casuing the bike to just turn with 0 input so i moved the colliders and box collider and reset up the wheel collider values and my script values that were missing a refrence after however no it will just rotate the y value constantly even if the input is 0 and i havent changed any code and it stopped the original problem but develouped this and i cant debug why any help would be amazing

MotorbikeController

public class MotorbikeController : MonoBehaviour
{
    [SerializeField] private WheelCollider frontWheelCollider;
    [SerializeField] private WheelCollider rearWheelCollider;
    [SerializeField] private float maxMotorTorque;
    [SerializeField] private float reverseTorque;
    [SerializeField] private float brakeTorque;
    [SerializeField] private float steeringAngle;
    [SerializeField] private float stallLimit = 60500;
    [Range(1f, 10f)]
    [SerializeField] private float revConstant;

    public int gear;

    private InputManager.MotorbikeActions controls;
    private float motorTorque;
    private float RPM;
    private Dictionary<int, float> gearToRatio = new Dictionary<int, float>();
    private bool stalled;
    public bool engineRunning;
    private MotorBikePlayerFeedbackController feedback;

    private float highestRPM = 0f;
    private float highestWheelRPM = 0f;
    private float highestMotorTorque = 0f;
    private int gearBefore;

    private void highest()
    {
        if (RPM > highestRPM)
        {
            highestRPM = RPM;
        }
        if (rearWheelCollider.rpm > highestWheelRPM)
        {
            highestWheelRPM = rearWheelCollider.rpm;
        }
        if (rearWheelCollider.motorTorque > highestMotorTorque)
        {
            highestMotorTorque = rearWheelCollider.motorTorque;
        }
    }

    private void OnApplicationQuit()
    {
        Debug.Log(highestRPM);
        Debug.Log(string.Concat("highest wheel rpm", highestWheelRPM));
        Debug.Log(string.Concat("highest motor torque", highestMotorTorque));
    }

    // Start is called before the first frame update
    void Start()
    {
        controls = SceneController.instance.inputManager.Motorbike;
        controls.Enable();
        InputManager.PlayerActions playerControls = SceneController.instance.inputManager.Player;
        playerControls.Disable();
        feedback = GetComponent<MotorBikePlayerFeedbackController>();
        gear = 0;
        engineRunning = false;
        populateGearToRatio();
    }

    private void populateGearToRatio()
    {
        gearToRatio.Add(1, 3.5f / 4.5f);
        gearToRatio.Add(2, 2.5f / 3.5f);
        gearToRatio.Add(3, 1.8f / 2.8f);
        gearToRatio.Add(4, 1.2f / 2.2f);
        gearToRatio.Add(5, 0.9f / 1.9f);
        gearToRatio.Add(6, 0.2f / 1.2f);
    }

    void FixedUpdate()
    {
        if (controls.Ignition.IsPressed())
        {
            engineRunning = true;
        }
        float horizontalInput = controls.Move.ReadValue<Vector2>().x;
        float verticalInput = controls.Move.ReadValue<Vector2>().y;

        frontWheelCollider.steerAngle = steeringAngle * horizontalInput;
        Debug.Log(frontWheelCollider.steerAngle);
        if (engineRunning && !controls.Clutch.IsInProgress() && !stalled)
        {
            rearWheelCollider.motorTorque = motorTorque * verticalInput;
            if (controls.Accelerate.IsInProgress())
            {
                feedback.acceleratingDelegate();
            }
            else if (!controls.Accelerate.IsInProgress())
            {
                feedback.stopAcceleratingDelegate();
            }
            RPMCalculations();
            StallCheck();
        }
        else
        {
            rearWheelCollider.motorTorque = 0f;
        }
        Shifting();
        ShiftingChangeChecks();
        Breaking();
        highest();
    }

    private void Breaking()
    {
        if (controls.BreakRear.IsPressed())
        {
            rearWheelCollider.brakeTorque = brakeTorque;
        }
        else
        {
            rearWheelCollider.brakeTorque = 0;
        }
        if (controls.BreakFront.IsPressed())
        {
            frontWheelCollider.brakeTorque = brakeTorque;
        }
        else
        {
            frontWheelCollider.brakeTorque = 0f;
        }
    }

    private void Shifting()
    {
        if (controls.Clutch.IsInProgress())
        {
            if (controls.ShiftUp.WasPressedThisFrame() && gear <= 6 && gear >= 0)
            {
                gearBefore = gear;
                ChangeGear(1);
            }
            else if (controls.ShiftDown.WasPressedThisFrame() && gear >= 0 && gear <= 6)
            {
                gearBefore = gear;
                ChangeGear(-1);
            }
            gear = Mathf.Clamp(gear, 0, 6);
        }
    }

    private void ChangeGear(int shiftValue)
    {
        gear += shiftValue;
        feedback.shifitngDelegate.Invoke();
        if (gear > gearBefore + 1 || gear < gearBefore - 1)
        {
            gear += -shiftValue;
        }
    }

    private void ShiftingChangeChecks()
    {
        if (gear == 0)
        {
            motorTorque = 0f;
        }
        else if (gear == 1)
        {
            motorTorque = maxMotorTorque / 6;
        }
        else if (gear == 2)
        {
            motorTorque = 2 * (maxMotorTorque / 6);
        }
        else if (gear == 3)
        {
            motorTorque = 3 * (maxMotorTorque / 6);
        }
        else if (gear == 4)
        {
            motorTorque = 4 * (maxMotorTorque / 6);
        }
        else if (gear == 5)
        {
            motorTorque = 5 * (maxMotorTorque / 6);
        }
        else if (gear == 6)
        {
            motorTorque = maxMotorTorque;
        }
    }

    public float GetRPM()
    {
        return RPM;
    }

    private void RPMCalculations()
    {
        if (gear > 0)
        {
            float gearRatio = gearToRatio[gear] * (rearWheelCollider.motorTorque + controls.Move.ReadValue<Vector2>().y) * revConstant;
            RPM = rearWheelCollider.rpm * gearRatio;
        }
    }

    private void Stall()
    {
        stalled = false;
        engineRunning = false;
    }

    private void StallCheck()
    {
        if (RPM > stallLimit && !controls.Clutch.IsInProgress() && engineRunning)
        {
            Stall();
        }
    }

    public float GetRearRPM()
    {
        return rearWheelCollider.rpm;
    }

    public float GetRearMotorTorque()
    {
        return rearWheelCollider.motorTorque;
    }
}

MotorBikePlayerFeedbackController

public class MotorBikePlayerFeedbackController : MonoBehaviour
{
    public delegate void ShifitngPlayerFeedbackDelegate();
    public ShifitngPlayerFeedbackDelegate shifitngDelegate;
    public delegate void AcceleratingPlayerFeedbackDelegate();
    public AcceleratingPlayerFeedbackDelegate acceleratingDelegate;
    public AcceleratingPlayerFeedbackDelegate stopAcceleratingDelegate;

    [SerializeField] private CameraShake camShakeScript;
    [SerializeField] private CinemachineFreeLook Vcam;
    [SerializeField] private NoiseSettings shiftShakeType;
    [SerializeField] private float lurchConstant;
    [SerializeField] private float shiftShakeIntensity;
    [SerializeField] private float shiftShakeDuration;
    [SerializeField] private NoiseSettings acceleratingShakeType;
    [SerializeField] private float accelearatingShakeIntensity;
    [SerializeField] private AudioSource shiftSound;
    [SerializeField] private AudioSource accelerateSound;

    private Rigidbody bikeRb;

    // Start is called before the first frame update
    void Start()
    {
        shifitngDelegate += ShiftLurch;
        shifitngDelegate += ShiftCamShake;
        shifitngDelegate += ShiftSounds;
        acceleratingDelegate += AcceleratingCameraShake;
        acceleratingDelegate += AccelerateSoundStart;
        stopAcceleratingDelegate += StopAccelSound;
        bikeRb = GetComponent<Rigidbody>();
    }

    private void ShiftLurch()
    {
        bikeRb.AddForce(Vector3.down * lurchConstant, ForceMode.Impulse);
    }

    private void ShiftCamShake()
    {
        camShakeScript.ShakeCameraCinemachineFreeLook(Vcam, shiftShakeType,  shiftShakeIntensity, shiftShakeDuration);
    }

    private void ShiftSounds()
    {
        shiftSound.Play();
    }

    private void AcceleratingCameraShake()
    {
        camShakeScript.ShakeCameraCinemachineFreeLook(Vcam, acceleratingShakeType, accelearatingShakeIntensity, 0.01f);
    }

    private void AccelerateSoundStart()
    {
        if (!accelerateSound.isPlaying)
        {
            accelerateSound.Play();
        }
    }

    private void StopAccelSound()
    {
        if (accelerateSound.isPlaying)
        {
            accelerateSound.Stop();
        }
    }
}

MotorbikeVisualController

public class MotorbikeVisualController : MonoBehaviour
{
    [SerializeField] private MotorbikeController motorController;
    [SerializeField] private Transform bikeVisual;
    [SerializeField] private float leanLimit;
    [SerializeField] private float leanConstant;

    private InputManager.MotorbikeActions controls;

    // Start is called before the first frame update
    void Start()
    {
        controls = SceneController.instance.inputManager.Motorbike;
    }

    private void FixedUpdate()
    {
        float horizontalInput = controls.Move.ReadValue<Vector2>().x;
        float verticalInput = controls.Move.ReadValue<Vector2>().y;
        LeanCalculations(horizontalInput);
    }

    private void LeanCalculations(float horizontal)
    {
        float rotateAngle = leanLimit * -horizontal;
        bikeVisual.localRotation = Quaternion.Euler(0f, 0f, rotateAngle);
    }
}

The problem is having just 2 wheel colliders, the physics cant work with that, you have to create 4 wheel colliders and put 2 of them at the front, and 2 of them at the back, really close togheter so it will simulate like it is a bike but you still have 4 wheels.
My drawing skills are awful but this will give you the idea:

i tried it could you maybe describe it abit more like how far the colliders need to be appart as when i had the 2 wheels i didnt start turning speradically but it still was shaking and the turning wasnt working properly it did work better with a higher steering angle but still not propperly