Background worker Run worker completed executes in the middle of do work when run for the second time

I have background worker where I am getting some callback in a thread and I am updating the UI and the progress bar as the states change. Currently there are 3 states 1) Cartridgr Drawer Closed 2) Processing 3) Processed.

First Time when the application starts everything works fine. The Run Worker Completed fires after the Processed state and I am launching an other success window through an event.

But for the second when I rerun the workflow without closing the application, I get the success Window when the worker still says Processing. Why is that also the remaining time that I am updating behaves incorrectly. Please help. (Please see the DoWork event Thread th I guess thats the issue).

 //This method is a RelayCommand thats called on some button click
    private void StartCurrentRun(bool obj)
            {
                this.worker = new BackgroundWorker();
                this.worker.WorkerReportsProgress = true;
                this.worker.WorkerSupportsCancellation = true;
                StartTimer();
                PropertyCallBackChangedInstance.PropertyChanged -= PropertyCallBackChangedInstance_PropertyChanged;
                WhenCancelledBlurVolumesGrid = false;
                this.worker.DoWork += this.DoWork;
                this.worker.ProgressChanged += this.ProgressChanged;
                this.worker.RunWorkerCompleted += Worker_RunWorkerCompleted;
                IsLiveProgress = true;
                this.worker.RunWorkerAsync();
            }

    private void DoWork(object sender, DoWorkEventArgs e)
            {


                    int OriginalTimeRemaining = SelectedVolumeEstimatedTime();
                    int TotalPrecentagebasedOnNumberOfStates = 50;
                    int PercentProgress = 100 / TotalPrecentagebasedOnNumberOfStates;
                    CurrentCartridgeStatus status = CurrentCartridgeStatus.NotProcessed;
                    var instance = ConnectToInstrument.InstrumentConnectionInstance;
                    instance.InitalizeRun();

                    Thread th = new Thread(() =>
                    {
                        PropertyCallBackChangedInstance.PropertyChanged += PropertyCallBackChangedInstance_PropertyChanged;
                    });

                    th.Start();
                    Thread th2 = new Thread(() =>
                      {
                          while (PropertyCallBackChangedInstance.CurrentCartridgeStatusChanged != CurrentCartridgeStatus.Processed)
                          {
                              lock (_objectForThread2)
                              {
                                  if (OriginalTimeRemaining > 0)
                                  {
                                      OriginalTimeRemaining -= 2;
                                  }
                                  var time = TimeSpan.FromSeconds(OriginalTimeRemaining);
                                  EstimatedTimeRemaining = string.Format("{0:00}:{1:00}:{2:00}",
                            time.Hours,
                            time.Minutes,
                            time.Seconds);
                                  OnPropertyChanged("EstimatedTimeRemaining");
                              }
                              Thread.Sleep(2000);
                          }
                      });
                    th2.Start();
                    int counter = 0;
                    for (int i = 0; i < PercentProgress; i++)
                    {
                        //Keep checking to see if the Run is cancelled
                        if (WhenCancelledBlurVolumesGrid) //That means the run is cancelled
                        {
                            if (worker.CancellationPending)
                            {
                                e.Cancel = true;
                                worker.CancelAsync();
                            }
                        }
                        for (int j = counter; j <= TotalPrecentagebasedOnNumberOfStates; j++)
                        {
                            worker.ReportProgress(Math.Min(j, 100));
                            if (status != CurrentCartridgeStatus.Processed)
                            {
                                Thread.Sleep(55);
                            }
                        }
                        counter = 50;
                        TotalPrecentagebasedOnNumberOfStates += 50;
                    }
                    th.Join();
                    th2.Join();
                }



            private void PropertyCallBackChangedInstance_PropertyChanged(object sender, PropertyChangedEventArgs e)
            {
                if (e.PropertyName == "CurrentCartridgeStatusChanged")
                {
                    var value = sender as InstrumentCallBackProperties;
                    CurrentStatus = EnumExtensions.GetDescription(value.CurrentCartridgeStatusChanged);
                }
            }

            private void ProgressChanged(object sender, ProgressChangedEventArgs e)
            {
                this.ProgressValue = e.ProgressPercentage;
            }

            private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
            {
                EstimatedTimeRemaining = "00:00:00";

                stopWatch.Stop();
                timer.Stop();

                Messenger.Default.Send(new NotificationMessage("RunComplete"));
                if (e.Cancelled)
                {
                    SelectedVolume = string.Empty;
                }


                else
                {
                    IsLiveProgress = false;

                    if (IsRunSuccessfullyComplete != null && !WhenCancelledBlurVolumesGrid) //This indicates that Success will only open when the run is complete
                    {

                        IsRunSuccessfullyComplete(NoErrors);//This event opens the success window from a different page
                    }

                WhenCancelledBlurVolumesGrid = true;
            }

    //I have some Dispose method that i am trying to do after the first run.
    public void Dispose()
            {
                if (this.worker != null)
                {
                    this.ProgressValue = 0;
                    this.worker.CancelAsync();
                    this.worker.Dispose();
                    this.worker = null;
                    timer = null;
                    stopWatch = null;
                    TimeElapsed = string.Empty;
                }
            }