diff --git a/src/accel/bvh4.rs b/src/accel/bvh4.rs
index c89f7ad..79bc3dd 100644
--- a/src/accel/bvh4.rs
+++ b/src/accel/bvh4.rs
@@ -1,7 +1,3 @@
-//! This BVH4 implementation is based on the ideas from the paper
-//! "Efficient Ray Tracing Kernels for Modern CPU Architectures"
-//! by Fuetterling et al.
-
 #![allow(dead_code)]
 
 use std::mem::{transmute, MaybeUninit};
diff --git a/src/main.rs b/src/main.rs
index eec57db..a8d10ed 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -289,30 +289,9 @@ fn main() {
                 // Print render stats
                 if !args.is_present("serialized_output") {
                     let rtime = t.tick();
-                    let ntime = rtime as f64 / rstats.total_time;
                     println!("\tRendered scene in {:.3}s", rtime);
-                    println!(
-                        "\t\tTrace:                  {:.3}s",
-                        ntime * rstats.trace_time
-                    );
                     println!("\t\t\tRays traced:          {}", rstats.ray_count);
-                    println!(
-                        "\t\t\tRays/sec:             {}",
-                        (rstats.ray_count as f64 / (ntime * rstats.trace_time) as f64) as u64
-                    );
                     println!("\t\t\tRay/node tests:       {}", rstats.accel_node_visits);
-                    println!(
-                        "\t\tInitial ray generation: {:.3}s",
-                        ntime * rstats.initial_ray_generation_time
-                    );
-                    println!(
-                        "\t\tRay generation:         {:.3}s",
-                        ntime * rstats.ray_generation_time
-                    );
-                    println!(
-                        "\t\tSample writing:         {:.3}s",
-                        ntime * rstats.sample_writing_time
-                    );
                 }
 
                 // Write to disk
diff --git a/src/renderer.rs b/src/renderer.rs
index 060faff..5e57c71 100644
--- a/src/renderer.rs
+++ b/src/renderer.rs
@@ -36,35 +36,23 @@ pub struct Renderer<'a> {
 
 #[derive(Debug, Copy, Clone)]
 pub struct RenderStats {
-    pub trace_time: f64,
     pub accel_node_visits: u64,
     pub ray_count: u64,
-    pub initial_ray_generation_time: f64,
-    pub ray_generation_time: f64,
-    pub sample_writing_time: f64,
     pub total_time: f64,
 }
 
 impl RenderStats {
     fn new() -> RenderStats {
         RenderStats {
-            trace_time: 0.0,
             accel_node_visits: 0,
             ray_count: 0,
-            initial_ray_generation_time: 0.0,
-            ray_generation_time: 0.0,
-            sample_writing_time: 0.0,
             total_time: 0.0,
         }
     }
 
     fn collect(&mut self, other: RenderStats) {
-        self.trace_time += other.trace_time;
         self.accel_node_visits += other.accel_node_visits;
         self.ray_count += other.ray_count;
-        self.initial_ray_generation_time += other.initial_ray_generation_time;
-        self.ray_generation_time += other.ray_generation_time;
-        self.sample_writing_time += other.sample_writing_time;
         self.total_time += other.total_time;
     }
 }
@@ -294,10 +282,6 @@ impl<'a> Renderer<'a> {
                     }
                 }
             }
-            // stats.initial_ray_generation_time += timer.tick() as f64;
-            // stats.ray_generation_time += timer.tick() as f64;
-            // stats.trace_time += timer.tick() as f64;
-            // stats.sample_writing_time += timer.tick() as f64;
 
             // Pre-calculate base64 encoding if needed
             let base64_enc = if do_blender_output {
@@ -342,7 +326,7 @@ impl<'a> Renderer<'a> {
         stats.total_time += total_timer.tick() as f64;
         stats.ray_count = tracer.rays_traced();
         ACCEL_NODE_RAY_TESTS.with(|anv| {
-            stats.accel_node_visits = anv.get();
+            stats.accel_node_visits += anv.get();
             anv.set(0);
         });