Network Player Direction in Unity

I am currently building my first multiplayer game in unity and having a little bit of an issue changing/transmitting the players direction over the network.

My current player controls class is this: using UnityEngine; using System.Collections;

 public class playerControls : MonoBehaviour {
 
     #region
 
     //Vars
     //Movements Vars
     public float runSpeed;
     Rigidbody mybody;
     Animator myAnimator;
     bool playerDirectionE;
 
     #endregion
 
     // Use this for initialization
     void Start () {
         mybody = GetComponent<Rigidbody>();
         myAnimator = GetComponent<Animator>();
         playerDirectionE = true;
         mybody.transform.eulerAngles = new Vector3(0, 90, 0);
 
 
     }
 
     // Update is called once per frame
     void Update () {
 
     }
 
     void FixedUpdate()
     {
         float move = Input.GetAxis("Horizontal");
         myAnimator.SetFloat("speed", Mathf.Abs(move)); //To intiate the charecter transition(move)
 
         mybody.velocity = new Vector3(move * runSpeed, mybody.velocity.y, 0); //move charecter along the x axis, and keep y on gravity, not touching the z axis
 
         if(move>0 && !playerDirectionE)
         {
             Flip();
         }
         else if(move<0 && playerDirectionE)
         {
             Flip();
         }
     }
 
     void Flip()
     {
         playerDirectionE = !playerDirectionE;
         Vector3 theScale = transform.localScale;
         theScale.z *= -1;
         transform.localScale = theScale;
     }
 }

I am using the following client information to send commands over the network:

 using UnityEngine;
 using System.Collections;
 using UnityEngine.Networking;
 using System.Collections.Generic;
 
 public class PlayerSyncRotation : NetworkBehaviour {
 
     [SyncVar(hook ="OnPlayerRotSynced")]
     private float syncPlayerRotation;
 
     [SerializeField]
     private Transform playerTransform;
     private float lerpRate = 15;
 
     private float lastPlayerRot;
     private float threshold = 1;
 
     private List<float> syncPlayerRotList = new List<float>();
     private float closeEneough = 0.3f;
     [SerializeField]
     private bool userHistoricalInterpolation;
 
     [Client]
     void OnPlayerRotSynced(float latestPlayerRotation)
     {
         syncPlayerRotation = latestPlayerRotation;
         syncPlayerRotList.Add(syncPlayerRotation);
     }
 
     [Command]
     void CmdProvideRotationsToServer(float playerRot)
     {
         syncPlayerRotation = playerRot;
     }
 
     [Client]
     void transmitRotations()
     {
         if (isLocalPlayer)
         {
             if(CheckIfBeyondThreshold(playerTransform.localScale.z, lastPlayerRot)){
                 lastPlayerRot = playerTransform.localScale.z;
                 CmdProvideRotationsToServer(lastPlayerRot);
 
             }
         }
     }
 
     bool CheckIfBeyondThreshold(float rot1, float rot2)
     {
         if (Mathf.Abs(rot1 - rot2) > threshold)
         {
             return true;
         }
         else
         {
             return false;
         }
     }
 
     // Use this for initialization
     void Start () {
 
     }
 
     // Update is called once per frame
     void Update () {
         lerpRotation();
     }
 
     void FixedUpdate()
     {
         transmitRotations();
     }
 
     void lerpRotation()
     {
         if (!isLocalPlayer)
         {
                 HistoricalInterpolation();
         }
     }
 
     void HistoricalInterpolation(){
         if (syncPlayerRotList.Count > 0)
         {
             LerpPlayerRotation(syncPlayerRotList[0]);
 
             if(Mathf.Abs(playerTransform.localEulerAngles.z - syncPlayerRotList[0]) < closeEneough)
             {
                 syncPlayerRotList.RemoveAt(0);
             }
             Debug.Log(syncPlayerRotList.Count.ToString() + "syncPlayerRotList Count");
         }
     }
 
     void LerpPlayerRotation(float rotAngle)
     {
         Vector3 playerNewRot = new Vector3(0, 0, rotAngle);
         playerTransform.rotation = Quaternion.Lerp(playerTransform.rotation, Quaternion.Euler(playerNewRot),lerpRate*Time.deltaTime);
     }
 }

My rotation looks fine on the client, but over the network on the second client, the rotation is broken and looks very wrong.

I have attached a link to a Webm where you can see the short video snippet of my problem HERE.

From the Webm you can see how my character rotation is broken, also notice how in my left client the idle character(the character on the right side) is facing right in the left client and facing left in right client.

Would anyone here have any input as to what I could be doing wrong or how I could fix this issue? any suggestions would be appreciated.