diff --git a/src/download.rs b/src/download.rs
index c24da93..82226ea 100644
--- a/src/download.rs
+++ b/src/download.rs
@@ -13,7 +13,7 @@ use crate::dlreport::*;
 
 struct RollingAverage {
     index: usize,
-    data: Vec<f32>
+    data: Vec<f64>
 }
 
 impl RollingAverage {
@@ -25,16 +25,31 @@ impl RollingAverage {
         }
     }
 
-    fn value(&self) -> f32 {
+    fn value(&self) -> f64 {
         if self.data.len() == 0 {
             0.0
         } else {
-            let sum: f32 = self.data.iter().sum();
-            sum / self.data.len() as f32
+            let mut max = self.data[0];
+
+            for v in self.data.iter() {
+                if *v > max {
+                    max = *v;
+                }
+            }
+
+            let mut sum: f64 = self.data.iter().sum();
+            let mut count = self.data.len();
+
+            if self.data.len() >= 3 {
+                sum -= max;
+                count -= 1;
+            }
+
+            sum / count as f64
         }
     }
 
-    fn add(&mut self, val: f32) {
+    fn add(&mut self, val: f64) {
         if self.data.capacity() == self.data.len() {
 
             self.data[self.index] = val;
@@ -160,18 +175,18 @@ pub async fn download_feedback_chunks(url: &str, into_file: &str, rep: DlReporte
         // Update the number of bytes downloaded since the last report
         last_bytecount += datalen;
 
-        let t_elapsed = t_last_speed.elapsed()?.as_millis();
+        let t_elapsed = t_last_speed.elapsed()?.as_secs_f64();
 
         // Update the reported download speed after every 5MB or every second 
         // depending on what happens first
-        if last_bytecount > 5_000_000 || t_elapsed >= 1000 {
+        if last_bytecount >= 3_000_000 || t_elapsed >= 0.8 {
 
             // Update rolling average
             average_speed.add(
-                (last_bytecount as f32) / (1_000.0 * t_elapsed as f32)
+                ((last_bytecount as f64) / t_elapsed) / 1_000_000.0
             );
 
-            speed_mbps = average_speed.value();
+            speed_mbps = average_speed.value() as f32;
 
             // Reset the time and bytecount
             last_bytecount = 0;
@@ -261,13 +276,18 @@ pub async fn download_feedback_multi(url: &str, into_file: &str, rep: DlReporter
 
     let rep_task = rep.clone();
 
+    let mut t_last = t_start.clone();
+
     joiners.push(tokio::task::spawn(async move {
 
         let rep = rep_task;
-        let mut update_counter: i32 = 0;
-        let mut dl_speeds = vec![0.0_f32; conn_count as usize];
+        //let mut dl_speeds = vec![0.0_f32; conn_count as usize];
         let mut progresses = vec![0; conn_count as usize];
 
+        let mut progress_last: u64 = 0;
+
+        let mut average_speed = RollingAverage::new(10);
+
         while let Some(update) = rx.recv().await {
             match update.status {
     
@@ -278,34 +298,43 @@ pub async fn download_feedback_multi(url: &str, into_file: &str, rep: DlReporter
     
                 },
                 DlStatus::Update {
-                    speed_mbps,
+                    speed_mbps: _,
                     bytes_curr
                 } => {
     
-                    dl_speeds[update.id as usize] = speed_mbps;
+                    //dl_speeds[update.id as usize] = speed_mbps;
                     progresses[update.id as usize] = bytes_curr;
     
-                    if update_counter >= 0 {
-                        update_counter = 0;
+                    
+                    let progress_curr = progresses.iter().sum();
+                    let progress_delta = progress_curr - progress_last;
+                    let t_elapsed = t_last.elapsed().unwrap().as_secs_f64();
+
+                    let speed_mbps = average_speed.value() as f32;
+
+                    // currently executes always, but might change
+                    if progress_delta >= 5_000_000 {
     
-                        let speed = dl_speeds.iter().sum();
-                        let curr = progresses.iter().sum();
+                        average_speed.add(
+                            ((progress_delta as f64) / 1_000_000.0) / t_elapsed
+                        );
+
+                        progress_last = progress_curr;
+                        t_last = SystemTime::now();
     
-                        rep.send(DlStatus::Update {
-                            speed_mbps: speed,
-                            bytes_curr: curr
-                        });
-    
-                    } else {
-                        update_counter += 1;
                     }
+                    
+                    rep.send(DlStatus::Update {
+                        speed_mbps: speed_mbps,
+                        bytes_curr: progress_curr
+                    });
     
                 },
                 DlStatus::Done {
                     duration_ms: _
                 } => {
     
-                    dl_speeds[update.id as usize] = 0.0;
+                    //dl_speeds[update.id as usize] = 0.0;
                     
                 },