Physics2D lag on increased timescale

I have been working on an infinite runner kind of game in which i am trying to implement a speedup powerup kind of thing . Something that will allow me to boost through the levels at a high speed

I did this by increasing the timescale value to 5.0 but doing that causes physics lag spikes in the profiler for mid end phones(LG - NEXUS 4)

i have quite a few colliers in the scene which i cannot reduce as the game kind of requires that collision accuracy

The impact is kind of unexpected as the areas with low physics2d actually have more active bodies at that time

is there anything i can do to reduce this , or any other way i can achieve this ?

Unity Version - 5.0.2f1

This scripts should be much more efficient. It controlls the entire movement and spawning of the level pieces.

using UnityEngine;

//Author: Oribow
public class EndlessRunner : MonoBehaviour {

    //Controlls the speed
    public float runningSpeed = 1;
    //Controlls the direction
    public Vector3 runningDir = Vector3.left;
    //Just for testing purpose
    public GameObject prefab;
   
    //Controlls the y height of the spawned objects
    public Transform levelSpawnPos;

    private float outOfCameraLeft;
    private float outOfCameraRight;
    private Camera mainCamera;
    private LevelPiece firstPiece;
    private LevelPiece lastPiece;

    void Start()
    {
        mainCamera = Camera.main;
        outOfCameraLeft = mainCamera.ScreenToWorldPoint(new Vector3(mainCamera.rect.xMin * Screen.width,0,0)).x;
        outOfCameraRight = mainCamera.ScreenToWorldPoint(new Vector3(mainCamera.rect.xMax * Screen.width, 0,0)).x;
        SpawnTheScreenFull();
    }

    void Update()
    {
        if (firstPiece.PosHorizontalRight < outOfCameraLeft)
        {
            LevelPiece oldPiece = firstPiece;
            Destroy(oldPiece.piece);
            SpawnTheScreenFull();
             firstPiece = oldPiece.next;
            oldPiece.next = null;
            
        }
        UpdateLevePiecePositions();
    }

    public void SpawnTheScreenFull()
    {
        Vector3 position = levelSpawnPos.position;
        if (lastPiece == null)
            position.x = outOfCameraLeft;
        else
            position.x = lastPiece.PosHorizontalRight;
        
        while (position.x < outOfCameraRight)
        {
            LevelPiece currentLevelPiece = new LevelPiece(GetRandomLevelPiece());
            position.x += currentLevelPiece.HalfWidth;
            currentLevelPiece.piece = Instantiate(currentLevelPiece.piece, position, Quaternion.identity) as GameObject;
            AddNewLevelPiece(currentLevelPiece);
            position.x += currentLevelPiece.HalfWidth;
        }
    }

    public GameObject GetRandomLevelPiece()
    {
        //Insert your random selector here
        return prefab;
    }

    public void AddNewLevelPiece(LevelPiece newPiece)
    {
        if (lastPiece == null)
        {
            lastPiece = newPiece;
            firstPiece = newPiece;
        }
        else
        {
            lastPiece.next = newPiece;
            lastPiece = newPiece;
        }
    }

    public void UpdateLevePiecePositions()
    {
        LevelPiece currentPiece = firstPiece;
        while (currentPiece != null)
        {
            currentPiece.piece.transform.Translate(runningDir * runningSpeed * Time.deltaTime);
            currentPiece = currentPiece.next;
        }
    }
}

LevelPiece:

using UnityEngine;

//Author: Oribow
public class LevelPiece
{
    public LevelPiece next;
    public GameObject piece;
    private Sprite sprite;
    public float PosHorizontalRight { get { return piece.transform.position.x + HalfWidth; } }
    public float PosHorizontalLeft { get { return piece.transform.position.x - HalfWidth; } }

    public LevelPiece(GameObject piece)
    {
        this.piece = piece;
        sprite = piece.GetComponent<SpriteRenderer>().sprite;
        next = null;
    }

    public float HalfWidth {
        get { return (piece.transform.localScale.x * sprite.bounds.size.x) / 2; }
    }

    public float Width
    {
        get { return piece.transform.localScale.x * sprite.bounds.size.x; }
    }
}