diff --git a/reco/L1/qa/CbmCaOutputQa.cxx b/reco/L1/qa/CbmCaOutputQa.cxx
index 4c39ab72c0451bab603654e985bcbb7884f7c3b5..bd946878538cd0f48c9dc14f373e7387b107e86d 100644
--- a/reco/L1/qa/CbmCaOutputQa.cxx
+++ b/reco/L1/qa/CbmCaOutputQa.cxx
@@ -714,8 +714,8 @@ InitStatus OutputQa::InitCanvases()
 
     // MC rapidity vs. MC momentum
     // auto* pc_mc_pMC_yMC =
-    MakeQaObject<CbmQaCanvas>("mc_pMC_yMC", "MC track MC mom. vs. rapidity ", kCXSIZEPX * 3, kCYSIZEPX * 2);
-    DrawSetOf<TH2F>(vCmpTypesGeneral, [&](ETrackType t) -> TH2F* { return fvpTrackHistograms[t]->fph_reco_pMC_yMC; });
+    MakeQaObject<CbmQaCanvas>("mc_ptMC_yMC", "MC track MC transverse mom. vs. rapidity ", kCXSIZEPX * 3, kCYSIZEPX * 2);
+    DrawSetOf<TH2F>(vCmpTypesGeneral, [&](ETrackType t) -> TH2F* { return fvpTrackHistograms[t]->fph_reco_ptMC_yMC; });
 
     // **  Efficiencies  **
 
diff --git a/reco/L1/qa/CbmCaTrackTypeQa.cxx b/reco/L1/qa/CbmCaTrackTypeQa.cxx
index db6156bfcbb0a73ca04a33e8a1830461766eb208..f5497a8dd10fbdbbc5df9ffc3e89767541d9d05a 100644
--- a/reco/L1/qa/CbmCaTrackTypeQa.cxx
+++ b/reco/L1/qa/CbmCaTrackTypeQa.cxx
@@ -43,28 +43,37 @@ void TrackTypeQa::Init()
   //
   fph_reco_p     = MakeQaObject<TH1F>("reco_p", "", kBinsP, kLoP, kUpP);
   fph_reco_pt    = MakeQaObject<TH1F>("reco_pt", "", kBinsPT, kLoPT, kUpPT);
-  fph_reco_eta   = MakeQaObject<TH1F>("reco_eta", "", kBinsETA, kLoETA, kUpETA);
   fph_reco_phi   = MakeQaObject<TH1F>("reco_phi", "", kBinsPHI, kLoPHI, kUpPHI);
   fph_reco_theta = MakeQaObject<TH1F>("reco_theta", "", kBinsTHETA, kLoTHETA, kUpTHETA);
   fph_reco_theta_phi =
     MakeQaObject<TH2F>("reco_theta_phi", "", kBinsPHI, kLoPHI, kUpPHI, kBinsTHETA, kLoTHETA, kUpTHETA);
-  fph_reco_tx    = MakeQaObject<TH1F>("reco_tx", "", kBinsTX, kLoTX, kUpTX);
-  fph_reco_ty    = MakeQaObject<TH1F>("reco_ty", "", kBinsTY, kLoTY, kUpTY);
-  fph_reco_ty_tx = MakeQaObject<TH2F>("reco_ty_tx", "", kBinsTX, kLoTX, kUpTX, kBinsTY, kLoTY, kUpTY);
-  fph_reco_fhitR = MakeQaObject<TH1F>("reco_fhitR", "", kBinsFHITR, kLoFHITR, kUpFHITR);
-  // TODO: ...
+  fph_reco_tx            = MakeQaObject<TH1F>("reco_tx", "", kBinsTX, kLoTX, kUpTX);
+  fph_reco_ty            = MakeQaObject<TH1F>("reco_ty", "", kBinsTY, kLoTY, kUpTY);
+  fph_reco_ty_tx         = MakeQaObject<TH2F>("reco_ty_tx", "", kBinsTX, kLoTX, kUpTX, kBinsTY, kLoTY, kUpTY);
+  fph_reco_eta           = MakeQaObject<TH1F>("reco_eta", "", kBinsETA, kLoETA, kUpETA);
+  fph_reco_fhitR         = MakeQaObject<TH1F>("reco_fhitR", "", kBinsFHITR, kLoFHITR, kUpFHITR);
+  fph_reco_nhits         = MakeQaObject<TH1F>("reco_nhits", "", kBinsNHITS, kLoNHITS, kUpNHITS);
+  fph_reco_fsta          = MakeQaObject<TH1F>("reco_fsta", "", kBinsNSTA, kLoNSTA, kUpNSTA);
+  fph_reco_lsta          = MakeQaObject<TH1F>("reco_lsta", "", kBinsNSTA, kLoNSTA, kUpNSTA);
+  fph_reco_chi2_ndf      = MakeQaObject<TH1F>("reco_chi2_ndf", "", kBinsCHI2NDF, kLoCHI2NDF, kUpCHI2NDF);
+  fph_reco_chi2_ndf_time = MakeQaObject<TH1F>("reco_chi2_ndf_time", "", kBinsCHI2NDF, kLoCHI2NDF, kUpCHI2NDF);
 
   fph_reco_p->SetTitle("Total momentum of reconstructed track;p^{reco} [GeV/c];Counts");
   fph_reco_pt->SetTitle("Transverse momentum of reconstructed track;p_{T}^{reco} [GeV/c];Counts");
   fph_reco_phi->SetTitle("Azimuthal angle of reconstructed track;#phi^{reco} [rad];Counts");
-  fph_reco_eta->SetTitle("Pseudorapidity of reconstructed track;#eta^{reco};Counts");
   fph_reco_theta->SetTitle("Polar angle of reconstructed track;#theta^{reco} [rad];Counts");
   fph_reco_theta_phi->SetTitle(
     "Polar angle vs. azimuthal angle of reconstructed track;#phi^{reco} [rad];#theta^{reco} [rad];Counts");
   fph_reco_tx->SetTitle("Slope along x-axis of reconstructed tracks;t_{x}^{reco};Counts");
   fph_reco_ty->SetTitle("Slope along y-axis of reconstructed tracks;t_{y}^{reco};Counts");
   fph_reco_ty_tx->SetTitle("Slope along y-axis vs. x-axis of reconstructed tracks;t_{x}^{reco};t_{y}^{reco};");
+  fph_reco_eta->SetTitle("Pseudorapidity of reconstructed track;#eta^{reco};Counts");
   fph_reco_fhitR->SetTitle("Distance of the first hit from z-axis for reconstructed tracks;R^{reco} [cm];Counts");
+  fph_reco_nhits->SetTitle("Number of hits of reconstructed tracks;N_{hits};Counts");
+  fph_reco_fsta->SetTitle("First station index of reconstructed tracks;ID_{station};Counts");
+  fph_reco_lsta->SetTitle("Last station index of reconstructed tracks;ID_{station};Counts");
+  fph_reco_chi2_ndf->SetTitle("#chi^{2}/NDF of reconstructed tracks;#chi^{2}/NDF;Counts");
+  fph_reco_chi2_ndf_time->SetTitle("Time #chi^{2}/NDF of reconstructed tracks;#chi^{2}/NDF;Counts");
 
   fCounterRecoTotal = 0;
 
@@ -72,41 +81,58 @@ void TrackTypeQa::Init()
     //
     // ** Distributions of reconstructed tracks vs. MC quantities **
     //
-    fph_reco_pMC     = MakeQaObject<TH1F>("reco_pMC", "", kBinsP, kLoP, kUpP);
-    fph_reco_etaMC   = MakeQaObject<TH1F>("reco_etaMC", "", kBinsETA, kLoETA, kUpETA);
-    fph_reco_yMC     = MakeQaObject<TH1F>("reco_yMC", "", kBinsY, kLoY, kUpY);
-    fph_reco_pMC_yMC = MakeQaObject<TH2F>("reco_pMC_yMC", "", kBinsY, kLoY, kUpY, kBinsP, kLoP, kUpP);
-    fph_reco_phiMC   = MakeQaObject<TH1F>("reco_phiMC", "", kBinsPHI, kLoPHI, kUpPHI);
-    fph_reco_thetaMC = MakeQaObject<TH1F>("reco_thetaMC", "", kBinsTHETA, kLoTHETA, kUpTHETA);
-    fph_reco_nhits   = MakeQaObject<TH1F>("reco_nhits", "", kBinsNHITS, kLoNHITS, kUpNHITS);
+    fph_reco_pMC      = MakeQaObject<TH1F>("reco_pMC", "", kBinsP, kLoP, kUpP);
+    fph_reco_ptMC     = MakeQaObject<TH1F>("reco_ptMC", "", kBinsPT, kLoPT, kUpPT);
+    fph_reco_yMC      = MakeQaObject<TH1F>("reco_yMC", "", kBinsY, kLoY, kUpY);
+    fph_reco_etaMC    = MakeQaObject<TH1F>("reco_etaMC", "", kBinsETA, kLoETA, kUpETA);
+    fph_reco_ptMC_yMC = MakeQaObject<TH2F>("reco_ptMC_yMC", "", kBinsY, kLoY, kUpY, kBinsPT, kLoPT, kUpPT);
+    fph_reco_phiMC    = MakeQaObject<TH1F>("reco_phiMC", "", kBinsPHI, kLoPHI, kUpPHI);
+    fph_reco_thetaMC  = MakeQaObject<TH1F>("reco_thetaMC", "", kBinsTHETA, kLoTHETA, kUpTHETA);
+    fph_reco_thetaMC_phiMC =
+      MakeQaObject<TH2F>("reco_thetaMC_phiMC", "", kBinsPHI, kLoPHI, kUpPHI, kBinsTHETA, kLoTHETA, kUpTHETA);
+    fph_reco_txMC = MakeQaObject<TH1F>("reco_txMC", "", kBinsTX, kLoTX, kUpTX);
+    fph_reco_tyMC = MakeQaObject<TH1F>("reco_tyMC", "", kBinsTY, kLoTY, kUpTY);
 
     fph_reco_pMC->SetTitle("MC total momentum of reconstructed track;p^{MC} [GeV/c];Counts");
+    fph_reco_ptMC->SetTitle("MC transverse momentum of reconstructed track;p_{T}^{MC} [GeV/c];Counts");
     fph_reco_yMC->SetTitle("MC rapidity of reconstructed track;y^{MC};Counts");
     fph_reco_etaMC->SetTitle("MC pseudorapidity of reconstructed track;#eta^{MC};Counts");
-    fph_reco_pMC_yMC->SetTitle("Transverse momentum of reconstructed track;y^{MC};p_{T}^{MC} [GeV/c];Counts");
-    fph_reco_phiMC->SetTitle("Azimuthal angle of reconstructed track;#phi^{MC} [rad];Counts");
-    fph_reco_thetaMC->SetTitle("Polar angle of reconstructed track;#theta^{MC} [rad];Counts");
-    fph_reco_nhits->SetTitle("Hit number of reconstructed tracks;N^{MC}_{hits};Counts");
+    fph_reco_ptMC_yMC->SetTitle("MC Transverse momentum of reconstructed track;y^{MC};p_{T}^{MC} [GeV/c];Counts");
+    fph_reco_phiMC->SetTitle("MC Azimuthal angle of reconstructed track;#phi^{MC} [rad];Counts");
+    fph_reco_thetaMC->SetTitle("MC Polar angle of reconstructed track;#theta^{MC} [rad];Counts");
+    fph_reco_thetaMC_phiMC->SetTitle(
+      "MC Polar angle vs. MC azimuthal angle of reconstructed track;#phi^{MC} [rad];#theta^{MC} [rad];Counts");
+    fph_reco_txMC->SetTitle("MC Slope along x-axis of reconstructed tracks;t_{x}^{MC};Counts");
+    fph_reco_tyMC->SetTitle("MC Slope along y-axis of reconstructed tracks;t_{y}^{MC};Counts");
 
 
+    //
+    // ** Distributions of MC tracks **
+    //
     fph_mc_pMC       = MakeQaObject<TH1F>("mc_pMC", "", kBinsP, kLoP, kUpP);
     fph_mc_etaMC     = MakeQaObject<TH1F>("mc_etaMC", "", kBinsETA, kLoETA, kUpETA);
     fph_mc_yMC       = MakeQaObject<TH1F>("mc_yMC", "", kBinsY, kLoY, kUpY);
-    fph_mc_pMC_yMC   = MakeQaObject<TH2F>("mc_pMC_yMC", "", kBinsY, kLoY, kUpY, kBinsP, kLoP, kUpP);
+    fph_mc_ptMC_yMC  = MakeQaObject<TH2F>("mc_ptMC_yMC", "", kBinsY, kLoY, kUpY, kBinsPT, kLoPT, kUpPT);
+    fph_mc_ptMC      = MakeQaObject<TH1F>("mc_ptMC", "", kBinsPT, kLoPT, kUpPT);
+    fph_mc_phiMC     = MakeQaObject<TH1F>("mc_phiMC", "", kBinsPHI, kLoPHI, kUpPHI);
+    fph_mc_thetaMC   = MakeQaObject<TH1F>("mc_thetaMC", "", kBinsTHETA, kLoTHETA, kUpTHETA);
+    fph_mc_thetaMC_phiMC =
+      MakeQaObject<TH2F>("mc_thetaMC_phiMC", "", kBinsPHI, kLoPHI, kUpPHI, kBinsTHETA, kLoTHETA, kUpTHETA);
     fph_mc_txMC      = MakeQaObject<TH1F>("mc_txMC", "", kBinsTX, kLoTX, kUpTX);
     fph_mc_tyMC      = MakeQaObject<TH1F>("mc_tyMC", "", kBinsTY, kLoTY, kUpTY);
     fph_mc_tyMC_txMC = MakeQaObject<TH2F>("mc_tyMC_txMC", "", kBinsTX, kLoTX, kUpTX, kBinsTY, kLoTY, kUpTY);
-    fph_mc_thetaMC_phiMC =
-      MakeQaObject<TH2F>("mc_thetaMC_phiMC", "", kBinsPHI, kLoPHI, kUpPHI, kBinsTHETA, kLoTHETA, kUpTHETA);
 
-    fph_mc_pMC->SetTitle("MC total momentum of MC tracks;p^{MC} [GeV/c];Counts");
-    fph_mc_yMC->SetTitle("MC rapidity of MC tracks;y^{MC};Counts");
-    fph_mc_etaMC->SetTitle("MC pseudorapidity of MC track;#eta^{MC};Counts");
-    fph_mc_pMC_yMC->SetTitle("MC total momentum vs. MC rapidity of MC tracks;y^{MC};p^{MC} [GeV/c];Counts");
+    fph_mc_pMC->SetTitle("Total momentum of MC tracks;p^{MC} [GeV/c];Counts");
+    fph_mc_etaMC->SetTitle("Pseudorapidity of MC tracks;#eta^{MC};Counts");
+    fph_mc_yMC->SetTitle("Rapidity of MC tracks;y^{MC};Counts");
+    fph_mc_ptMC_yMC->SetTitle("Transverse momentum vs. rapidity of MC tracks;y^{MC};p_{T}^{MC} [GeV/c];Counts");
+    fph_mc_ptMC->SetTitle("Transverse momentum of MC track;p_{T}^{MC} [GeV/c];Counts");
+    fph_mc_phiMC->SetTitle("Azimuthal angle of MC track;#phi^{MC} [rad];Counts");
+    fph_mc_thetaMC->SetTitle("Polar angle of MC track;#theta^{MC} [rad];Counts");
+    fph_mc_thetaMC_phiMC->SetTitle("Polar angle vs. azimuthal angle of MC track;#phi^{MC} [rad];#theta^{MC} [rad]");
     fph_mc_txMC->SetTitle("Slope along x-axis of MC tracks;t_{x}^{MC};Counts");
     fph_mc_tyMC->SetTitle("Slope along y-axis of MC tracks;t_{y}^{MC};Counts");
     fph_mc_tyMC_txMC->SetTitle("Slope along y-axis vs. x-axis of MC tracks;t_{x}^{MC};t_{y}^{MC};");
-    fph_mc_thetaMC_phiMC->SetTitle("Polar angle vs. azimuthal angle of MC track;#phi^{MC} [rad];#theta^{MC} [rad]");
 
     //
     // ** Efficiencies **
@@ -118,7 +144,7 @@ void TrackTypeQa::Init()
     fph_eff_thetaMC = MakeQaObject<TProfile>("eff_thetaMC", "", kBinsTHETA, kLoTHETA, kUpTHETA, 0., 1.);
     fph_eff_etaMC   = MakeQaObject<TProfile>("eff_etaMC", "", kBinsTHETA, kLoTHETA, kUpTHETA, 0., 1.);
     fph_eff_phiMC   = MakeQaObject<TProfile>("eff_phiMC", "", kBinsPHI, kLoPHI, kUpPHI, 0., 1.);
-    fph_eff_nhitsMC = MakeQaObject<TProfile>("eff_nhitsMC", "", kBinsNHITS, kLoNHITS, kUpNHITS, 0., 1.);
+    fph_eff_nhitsMC = MakeQaObject<TProfile>("eff_nhitsMC", "", kBinsNSTA, kLoNSTA, kUpNSTA, 0., 1.);
     fph_eff_txMC    = MakeQaObject<TProfile>("eff_txMC", "", kBinsTX, kLoTX, kUpTX, 0., 1.);
     fph_eff_tyMC    = MakeQaObject<TProfile>("eff_tyMC", "", kBinsTY, kLoTY, kUpTX, 0., 1.);
 
@@ -138,21 +164,22 @@ void TrackTypeQa::Init()
     fph_eff_int->SetTitle("Integrated efficiency;;#epsilon_{CA}");
     fph_eff_pMC->SetTitle("Efficiency vs. MC total momentum;p_{MC} [GeV/c];#epsilon_{CA}");
     fph_eff_yMC->SetTitle("Efficiency vs. MC rapidity;y_{MC};#epsilon");
-    fph_eff_ptMC->SetTitle("Efficiency vs. MC total momentum;p_{T}^{MC} [GeV/c];#epsilon_{CA}");
+    fph_eff_ptMC->SetTitle("Efficiency vs. MC transverse momentum;p_{T}^{MC} [GeV/c];#epsilon_{CA}");
     fph_eff_thetaMC->SetTitle("Efficiency vs. MC polar angle;#theta^{MC};#epsilon_{CA}");
     fph_eff_etaMC->SetTitle("Efficiency vs. MC pseudorapidity;#eta^{MC};#epsilon_{CA}");
     fph_eff_phiMC->SetTitle("Efficiency vs. MC azimuthal angle;#phi^{MC};#epsilon_{CA}");
-    fph_eff_nhitsMC->SetTitle("Efficiency vs. MC number of stations with hits;N_{hit}^{MC};#epsilon_{CA}");
+    fph_eff_nhitsMC->SetTitle("Efficiency vs. number of hits;N_{hit}^{MC};#epsilon_{CA}");
     fph_eff_txMC->SetTitle("Efficiency vs. MC slope along x-axis;t_{x}^{MC};#epsilon_{CA}");
     fph_eff_tyMC->SetTitle("Efficiency vs. MC slope along y-axis;t_{y}^{MC};#epsilon_{CA}");
 
-    fph_eff_pMC_yMC = MakeQaObject<TProfile2D>("eff_pMC_yMC", "", kBinsY, kLoY, kUpY, kBinsP, kLoP, kUpP, 0., 1.);
+    fph_eff_ptMC_yMC = MakeQaObject<TProfile2D>("eff_ptMC_yMC", "", kBinsY, kLoY, kUpY, kBinsPT, kLoPT, kUpPT, 0., 1.);
     fph_eff_thetaMC_phiMC =
       MakeQaObject<TProfile2D>("eff_theta_phi", "", kBinsPHI, kLoPHI, kUpPHI, kBinsTHETA, kLoTHETA, kUpTHETA, 0., 1.);
 
-    fph_eff_pMC_yMC->SetTitle("Efficiency vs. MC total momentum and MC rapidity;y^{MC};#epsilon_{CA};p^{MC} [GeV/c]");
+    fph_eff_ptMC_yMC->SetTitle(
+      "Efficiency vs. MC transverse momentum and MC rapidity;y^{MC};#epsilon_{CA};p_{T}^{MC} [GeV/c]");
     fph_eff_thetaMC_phiMC->SetTitle(
-      "Efficiency vs. MC polar and azimuthal angles;#phi^{MC} [rad];#theta^{MC} [rad];#epsilon_{CA}");
+      "Efficiency vs. MC polar and MC azimuthal angles;#phi^{MC} [rad];#theta^{MC} [rad];#epsilon_{CA}");
     //
     // ** Track fit parameter properties (residuals and pulls) **
     //
@@ -185,15 +212,25 @@ void TrackTypeQa::Init()
 void TrackTypeQa::FillRecoTrack(int iTrkReco, double weight)
 {
   const auto& recoTrack = (*fpvRecoTracks)[iTrkReco];
+  const auto& fstHit    = (*fpvHits)[recoTrack.GetFirstHitIndex()];
+  const auto& lstHit    = (*fpvHits)[recoTrack.GetLastHitIndex()];
+
   fph_reco_p->Fill(recoTrack.GetP(), weight);
   fph_reco_pt->Fill(recoTrack.GetPt(), weight);
   fph_reco_eta->Fill(recoTrack.GetEta(), weight);
   fph_reco_phi->Fill(recoTrack.GetPhi(), weight);
   fph_reco_theta->Fill(recoTrack.GetTheta(), weight);
+  fph_reco_theta_phi->Fill(recoTrack.GetPhi(), recoTrack.GetTheta(), weight);
   fph_reco_tx->Fill(recoTrack.GetTx(), weight);
   fph_reco_ty->Fill(recoTrack.GetTy(), weight);
   fph_reco_ty_tx->Fill(recoTrack.GetTx(), recoTrack.GetTy(), weight);
-  fph_reco_theta_phi->Fill(recoTrack.GetPhi(), recoTrack.GetTheta(), weight);
+  fph_reco_nhits->Fill(recoTrack.GetNofHits(), weight);
+  fph_reco_fhitR->Fill(fstHit.GetR());
+  fph_reco_fsta->Fill(fstHit.GetStationId(), weight);
+  fph_reco_lsta->Fill(lstHit.GetStationId(), weight);
+  fph_reco_chi2_ndf->Fill(recoTrack.GetChiSq() / recoTrack.GetNdf());
+  fph_reco_chi2_ndf_time->Fill(recoTrack.GetChiSqTime() / recoTrack.GetNdfTime());
+
   ++fCounterRecoTotal;
   if (fbUseMC) {
     int iTrkMC = recoTrack.GetMatchedMCTrackIndex();
@@ -201,9 +238,15 @@ void TrackTypeQa::FillRecoTrack(int iTrkReco, double weight)
       /// TODO: fill mass hypothesis into CbmL1Track
       const auto& mcTrack = fpMCData->GetTrack(iTrkMC);
       fph_reco_pMC->Fill(mcTrack.GetP(), weight);
-      fph_reco_etaMC->Fill(mcTrack.GetEta(), weight);
+      fph_reco_ptMC->Fill(mcTrack.GetPt(), weight);
       fph_reco_yMC->Fill(mcTrack.GetRapidity(), weight);
-      fph_reco_pMC_yMC->Fill(mcTrack.GetRapidity(), mcTrack.GetP(), weight);
+      fph_reco_etaMC->Fill(mcTrack.GetEta(), weight);
+      fph_reco_ptMC_yMC->Fill(mcTrack.GetRapidity(), mcTrack.GetPt(), weight);
+      fph_reco_phiMC->Fill(mcTrack.GetPhi(), weight);
+      fph_reco_thetaMC->Fill(mcTrack.GetTheta(), weight);
+      fph_reco_thetaMC_phiMC->Fill(mcTrack.GetPhi(), mcTrack.GetTheta(), weight);
+      fph_reco_txMC->Fill(mcTrack.GetTx(), weight);
+      fph_reco_tyMC->Fill(mcTrack.GetTy(), weight);
 
       // *****************************
       // ** Track fit parameters QA **
@@ -285,11 +328,14 @@ void TrackTypeQa::FillMCTrack(int iTrkMC, double weight)
   fph_mc_pMC->Fill(mcTrack.GetP(), weight);
   fph_mc_etaMC->Fill(mcTrack.GetEta(), weight);
   fph_mc_yMC->Fill(mcTrack.GetRapidity(), weight);
-  fph_mc_pMC_yMC->Fill(mcTrack.GetRapidity(), mcTrack.GetP(), weight);
+  fph_mc_ptMC_yMC->Fill(mcTrack.GetRapidity(), mcTrack.GetPt(), weight);
+  fph_mc_ptMC->Fill(mcTrack.GetPt(), weight);
+  fph_mc_phiMC->Fill(mcTrack.GetPhi(), weight);
+  fph_mc_thetaMC->Fill(mcTrack.GetTheta(), weight);
+  fph_mc_thetaMC_phiMC->Fill(mcTrack.GetPhi(), mcTrack.GetTheta(), weight);
   fph_mc_txMC->Fill(mcTrack.GetTx(), weight);
   fph_mc_tyMC->Fill(mcTrack.GetTy(), weight);
   fph_mc_tyMC_txMC->Fill(mcTrack.GetTx(), mcTrack.GetTy(), weight);
-  fph_mc_thetaMC_phiMC->Fill(mcTrack.GetPhi(), mcTrack.GetTheta(), weight);
 
   // ** Efficiencies **
   bool bReco           = mcTrack.IsReconstructed();
@@ -325,7 +371,7 @@ void TrackTypeQa::FillMCTrack(int iTrkMC, double weight)
   fph_eff_txMC->Fill(mcTrack.GetTx(), bReco);
   fph_eff_tyMC->Fill(mcTrack.GetTy(), bReco);
 
-  fph_eff_pMC_yMC->Fill(mcTrack.GetRapidity(), mcTrack.GetP(), bReco);
+  fph_eff_ptMC_yMC->Fill(mcTrack.GetRapidity(), mcTrack.GetPt(), bReco);
   fph_eff_thetaMC_phiMC->Fill(mcTrack.GetPhi(), mcTrack.GetTheta(), bReco);
 }
 
diff --git a/reco/L1/qa/CbmCaTrackTypeQa.h b/reco/L1/qa/CbmCaTrackTypeQa.h
index 551ed0b3def18f75ca6aae7cb85845f43f227e8d..38171e3a8db4d8c5dcffc9af3a971b630e88d57f 100644
--- a/reco/L1/qa/CbmCaTrackTypeQa.h
+++ b/reco/L1/qa/CbmCaTrackTypeQa.h
@@ -200,37 +200,39 @@ namespace cbm::ca
     //  to be separated with "_" (example: "p_yMC" -- reconstructed momentum vs MC rapidity)
 
     // ** Histograms from reconstructed information only **
-    TH1F* fph_reco_p         = nullptr;  ///< Total momentum over charge of reconstructed tracks
-    TH1F* fph_reco_pt        = nullptr;  ///< Transverse momentum over charge of reconstructed tracks
-    TH1F* fph_reco_phi       = nullptr;  ///< Azimuthal angle of reconstructed tracks
-    TH1F* fph_reco_theta     = nullptr;  ///< Polar angle of reconstructed tracks
-    TH2F* fph_reco_theta_phi = nullptr;  ///< Polar angle vs. azimuthal angle of reconstructed tracks
-    TH1F* fph_reco_tx        = nullptr;  ///< Slope along x-axis of reconstructed tracks
-    TH1F* fph_reco_ty        = nullptr;  ///< Slope along y-axis of reconstructed tracks
-    TH2F* fph_reco_ty_tx     = nullptr;  ///< Slope along x-axis vs y-axis of reconstructed tracks
-    TH1F* fph_reco_eta       = nullptr;  ///< Pseudo-rapidity of reconstructed tracks
-    TH1F* fph_reco_fhitR     = nullptr;  ///< Distance of the first hit from z-axis for reconstructed tracks
-    TH1F* fph_reco_nhits     = nullptr;  ///< Hit number of reconstructed tracks
-    TH1F* fph_reco_fsta      = nullptr;  ///< First station index of reconstructed tracks
-    TH1F* fph_reco_chi2_ndf  = nullptr;  ///< Fit chi2 over NDF of reconstructed tracks
+    TH1F* fph_reco_p             = nullptr;  ///< Total momentum over charge of reconstructed tracks
+    TH1F* fph_reco_pt            = nullptr;  ///< Transverse momentum over charge of reconstructed tracks
+    TH1F* fph_reco_phi           = nullptr;  ///< Azimuthal angle of reconstructed tracks
+    TH1F* fph_reco_theta         = nullptr;  ///< Polar angle of reconstructed tracks
+    TH2F* fph_reco_theta_phi     = nullptr;  ///< Polar angle vs. azimuthal angle of reconstructed tracks
+    TH1F* fph_reco_tx            = nullptr;  ///< Slope along x-axis of reconstructed tracks
+    TH1F* fph_reco_ty            = nullptr;  ///< Slope along y-axis of reconstructed tracks
+    TH2F* fph_reco_ty_tx         = nullptr;  ///< Slope along x-axis vs y-axis of reconstructed tracks
+    TH1F* fph_reco_eta           = nullptr;  ///< Pseudo-rapidity of reconstructed tracks
+    TH1F* fph_reco_nhits         = nullptr;  ///< Hit number of reconstructed tracks
+    TH1F* fph_reco_fhitR         = nullptr;  ///< Distance of the first hit from z-axis for reconstructed tracks
+    TH1F* fph_reco_fsta          = nullptr;  ///< First station index of reconstructed tracks
+    TH1F* fph_reco_lsta          = nullptr;  ///< Last station index of reconstructed tracks
+    TH1F* fph_reco_chi2_ndf      = nullptr;  ///< Fit chi2 over NDF of reconstructed tracks
+    TH1F* fph_reco_chi2_ndf_time = nullptr;  ///< Fit chi2 over NDF of reconstructed tracks for time
 
     // ** Reconstructed track distributions, requiring MC information **
-    TH1F* fph_reco_pMC     = nullptr;  ///< MC total momentum over charge of reconstructed tracks
-    TH1F* fph_reco_yMC     = nullptr;  ///< MC rapidity of reconstructed tracks
-    TH1F* fph_reco_etaMC   = nullptr;  ///< MC pseudo-rapidity of reconstructed tracks
-    TH2F* fph_reco_p_yMC   = nullptr;  ///< Total momentum vs MC rapidity of reconstructed tracks
-    TH2F* fph_reco_pMC_yMC = nullptr;  ///< MC total momentum vs MC rapidity of reconstructed tracks
-    TH1F* fph_reco_ptMC    = nullptr;  ///< Transverse momentum over charge of reconstructed tracks
-    TH1F* fph_reco_phiMC   = nullptr;  ///< Azimuthal angle of reconstructed tracks
-    TH1F* fph_reco_thetaMC = nullptr;  ///< Polar angle of reconstructed tracks
-    TH1F* fph_reco_txMC    = nullptr;  ///< Slope along x-axis of reconstructed tracks
-    TH1F* fph_reco_tyMC    = nullptr;  ///< Slope along y-axis of reconstructed tracks
+    TH1F* fph_reco_pMC           = nullptr;  ///< MC total momentum over charge of reconstructed tracks
+    TH1F* fph_reco_ptMC          = nullptr;  ///< MC transverse momentum over charge of reconstructed tracks
+    TH1F* fph_reco_yMC           = nullptr;  ///< MC rapidity of reconstructed tracks
+    TH1F* fph_reco_etaMC         = nullptr;  ///< MC pseudo-rapidity of reconstructed tracks
+    TH2F* fph_reco_ptMC_yMC      = nullptr;  ///< MC transverse momentum vs MC rapidity of reconstructed tracks
+    TH1F* fph_reco_phiMC         = nullptr;  ///< MC Azimuthal angle of reconstructed tracks
+    TH1F* fph_reco_thetaMC       = nullptr;  ///< MC Polar angle of reconstructed tracks
+    TH2F* fph_reco_thetaMC_phiMC = nullptr;  ///< MC Polar angle vs. azimuthal angle of reconstructed tracks
+    TH1F* fph_reco_txMC          = nullptr;  ///< MC Slope along x-axis of reconstructed tracks
+    TH1F* fph_reco_tyMC          = nullptr;  ///< MC Slope along y-axis of reconstructed tracks
 
     // ** MC track distributions **
     TH1F* fph_mc_pMC           = nullptr;  ///< MC total momentum over charge of MC tracks
     TH1F* fph_mc_yMC           = nullptr;  ///< MC rapidity of MC tracks
     TH1F* fph_mc_etaMC         = nullptr;  ///< MC pseudo-rapidity of MC tracks
-    TH2F* fph_mc_pMC_yMC       = nullptr;  ///< MC total momentum vs. MC rapidity of MC tracks
+    TH2F* fph_mc_ptMC_yMC      = nullptr;  ///< MC transverse momentum vs. MC rapidity of MC tracks
     TH1F* fph_mc_ptMC          = nullptr;  ///< Transverse momentum over charge of MC tracks
     TH1F* fph_mc_phiMC         = nullptr;  ///< Azimuthal angle of MC tracks
     TH1F* fph_mc_thetaMC       = nullptr;  ///< Polar angle of MC tracks
@@ -247,13 +249,13 @@ namespace cbm::ca
     TProfile* fph_eff_thetaMC = nullptr;  ///< Efficiency vs. MC polar angle
     TProfile* fph_eff_etaMC   = nullptr;  ///< Efficiency vs. MC pseudorapidity
     TProfile* fph_eff_phiMC   = nullptr;  ///< Efficiency vs. MC azimuthal angle
-    TProfile* fph_eff_nhitsMC = nullptr;  ///< Efficiency vs. MC number of hits
+    TProfile* fph_eff_nhitsMC = nullptr;  ///< Efficiency vs. MC number of hits (total number of stations with a)
     TProfile* fph_eff_txMC    = nullptr;  ///< Efficiency vs. MC slope along x-axis
     TProfile* fph_eff_tyMC    = nullptr;  ///< Efficiency vs. MC slope along y-axis
 
 
     TProfile2D* fph_eff_thetaMC_phiMC = nullptr;  ///< Efficiency vs. MC theta and MC phi
-    TProfile2D* fph_eff_pMC_yMC       = nullptr;  ///< Efficiency vs. MC momentum and MC rapidity
+    TProfile2D* fph_eff_ptMC_yMC      = nullptr;  ///< Efficiency vs. MC transverse momentum and MC rapidity
     TProfile2D* fph_eff_tyMC_txMC     = nullptr;  ///< Efficiency vs. MC slopes
 
     // ** Fit QA **
@@ -290,6 +292,7 @@ namespace cbm::ca
     bool fbUseMC    = false;  ///< Flag: true - MC information is used
     TString fsTitle = "";     ///< Title of the track category
 
+    // TODO: SZh 20.03.2024: Maybe replace CbmL1Track with CaTrack?
     ca::Vector<CbmL1Track>* fpvRecoTracks        = nullptr;  ///< Pointer to vector of reconstructed tracks
     ca::Vector<CbmL1HitDebugInfo>* fpvHits       = nullptr;  ///< Pointer to vector of reconstructed hits
     tools::MCData* fpMCData                      = nullptr;  ///< Pointer to MC data object
@@ -310,36 +313,43 @@ namespace cbm::ca
     // **************************
 
     // ** Binning **
-    static constexpr int kBinsP      = 100;   ///< Number of bins, total momentum
-    static constexpr double kLoP     = 0.;    ///< Lower boundary, total momentum [GeV/c]
-    static constexpr double kUpP     = 10.;   ///< Upper boundary, total momentum [GeV/c]
-    static constexpr int kBinsPT     = 100;   ///< Number of bins, transverse momentum
-    static constexpr double kLoPT    = 0.;    ///< Lower boundary, transverse momentum [GeV/c]
-    static constexpr double kUpPT    = 10.;   ///< Upper boundary, transverse momentum [GeV/c]
-    static constexpr int kBinsETA    = 40;    ///< Number of bins, pseudo-rapidity
-    static constexpr double kLoETA   = 0.;    ///< Lower boundary, pseudo-rapidity
-    static constexpr double kUpETA   = 4.;    ///< Upper boundary, pseudo-rapidity
-    static constexpr int kBinsY      = 40;    ///< Number of bins, rapidity
-    static constexpr double kLoY     = 0.;    ///< Lower boundary, rapidity
-    static constexpr double kUpY     = 4.;    ///< Upper boundary, rapidity
-    static constexpr int kBinsPHI    = 68;    ///< Number of bins, azimuthal angle
-    static constexpr double kLoPHI   = -3.2;  ///< Lower boundary, azimuthal angle [rad]
-    static constexpr double kUpPHI   = +3.2;  ///< Upper boundary, azimuthal angle [rad]
-    static constexpr int kBinsTHETA  = 68;    ///< Number of bins, polar angle
-    static constexpr double kLoTHETA = 0.;    ///< Lower boundary, polar angle [rad]
-    static constexpr double kUpTHETA = 3.2;   ///< Upper boundary, polar angle [rad]
-    static constexpr int kBinsTX     = 80;    ///< Number of bins, slope along x
-    static constexpr double kLoTX    = -2.;   ///< Lower boundary, slope along x
-    static constexpr double kUpTX    = +2.;   ///< Upper boundary, slope along x
-    static constexpr int kBinsTY     = 80;    ///< Number of bins, slope along y
-    static constexpr double kLoTY    = -2.;   ///< Lower boundary, slope along y
-    static constexpr double kUpTY    = +2.;   ///< Upper boundary, slope along y
-    static constexpr int kBinsNHITS  = 15;    ///< Number of bins, number of hits
-    static constexpr double kLoNHITS = -0.5;  ///< Lower boundary, number of hits
-    static constexpr double kUpNHITS = 14.5;  ///< Upper boundary, number of hits
-    static constexpr int kBinsFHITR  = 50;    ///< Number of bins, transverse distance of the 1st hit from z-axis
-    static constexpr double kLoFHITR = 0.;    ///< Lower boundary, transverse distance of the 1st hit from z-axis [cm]
-    static constexpr double kUpFHITR = 150.;  ///< Upper boundary, transverse distance of the 1st hit from z-axis [cm]
+    // TODO: SZh 20.03.2024: Make yaml-configurable
+    static constexpr int kBinsP        = 120;   ///< Number of bins, total momentum
+    static constexpr double kLoP       = 0.;    ///< Lower boundary, total momentum [GeV/c]
+    static constexpr double kUpP       = 12.;   ///< Upper boundary, total momentum [GeV/c]
+    static constexpr int kBinsPT       = 100;   ///< Number of bins, transverse momentum
+    static constexpr double kLoPT      = 0.;    ///< Lower boundary, transverse momentum [GeV/c]
+    static constexpr double kUpPT      = 4.;    ///< Upper boundary, transverse momentum [GeV/c]
+    static constexpr int kBinsETA      = 40;    ///< Number of bins, pseudo-rapidity
+    static constexpr double kLoETA     = 0.;    ///< Lower boundary, pseudo-rapidity
+    static constexpr double kUpETA     = 4.;    ///< Upper boundary, pseudo-rapidity
+    static constexpr int kBinsY        = 40;    ///< Number of bins, rapidity
+    static constexpr double kLoY       = 0.;    ///< Lower boundary, rapidity
+    static constexpr double kUpY       = 4.;    ///< Upper boundary, rapidity
+    static constexpr int kBinsPHI      = 68;    ///< Number of bins, azimuthal angle
+    static constexpr double kLoPHI     = -3.2;  ///< Lower boundary, azimuthal angle [rad]
+    static constexpr double kUpPHI     = +3.2;  ///< Upper boundary, azimuthal angle [rad]
+    static constexpr int kBinsTHETA    = 68;    ///< Number of bins, polar angle
+    static constexpr double kLoTHETA   = 0.;    ///< Lower boundary, polar angle [rad]
+    static constexpr double kUpTHETA   = 3.2;   ///< Upper boundary, polar angle [rad]
+    static constexpr int kBinsTX       = 80;    ///< Number of bins, slope along x
+    static constexpr double kLoTX      = -2.;   ///< Lower boundary, slope along x
+    static constexpr double kUpTX      = +2.;   ///< Upper boundary, slope along x
+    static constexpr int kBinsTY       = 80;    ///< Number of bins, slope along y
+    static constexpr double kLoTY      = -2.;   ///< Lower boundary, slope along y
+    static constexpr double kUpTY      = +2.;   ///< Upper boundary, slope along y
+    static constexpr int kBinsNHITS    = 15;    ///< Number of bins, number of hits
+    static constexpr double kLoNHITS   = -0.5;  ///< Lower boundary, number of hits
+    static constexpr double kUpNHITS   = 14.5;  ///< Upper boundary, number of hits
+    static constexpr int kBinsFHITR    = 50;    ///< Number of bins, transverse dist. of the 1st hit from z-axis
+    static constexpr double kLoFHITR   = 0.;    ///< Lower boundary, transverse dist. of the 1st hit from z-axis [cm]
+    static constexpr double kUpFHITR   = 150.;  ///< Upper boundary, transverse dist. of the 1st hit from z-axis [cm]
+    static constexpr int kBinsNSTA     = 12;    ///< Number of bins, number of stations
+    static constexpr double kLoNSTA    = -0.5;  ///< Lower boundary, number of stations
+    static constexpr double kUpNSTA    = 11.5;  ///< Upper boundary, number of stations
+    static constexpr int kBinsCHI2NDF  = 200;   ///< Number of bins, chi2 over NDF
+    static constexpr double kLoCHI2NDF = 0.;    ///< Lower boundary, chi2 over NDF
+    static constexpr double kUpCHI2NDF = 20.;   ///< Upper boundary, chi2 over NDF
 
     // ** Drawing attributes **
     Color_t fMarkerColor = 1;   ///< Marker color