diff --git a/src/animations/animation_base.hpp b/src/animations/animation_base.hpp
index ae84c6447..2bc335bc3 100644
--- a/src/animations/animation_base.hpp
+++ b/src/animations/animation_base.hpp
@@ -47,9 +47,6 @@ private:
     *  one time only (which might get triggered more than once). */
     enum AnimTimeType { ATT_CYCLIC, ATT_CYCLIC_ONCE } m_anim_type;
 
-    /** True if the animation is currently playing. */
-    bool  m_playing;
-
     /** The current time used in the IPOs. */
     float m_current_time;
 
@@ -66,6 +63,9 @@ protected:
     /** All IPOs for this animation. */
     PtrVector<Ipo>  m_all_ipos;
 
+    /** True if the animation is currently playing. */
+    bool  m_playing;
+    
 public:
                  AnimationBase(const XMLNode &node);
                  AnimationBase(Ipo *ipo);
diff --git a/src/animations/three_d_animation.cpp b/src/animations/three_d_animation.cpp
index 793dc2fbb..38853540f 100644
--- a/src/animations/three_d_animation.cpp
+++ b/src/animations/three_d_animation.cpp
@@ -81,6 +81,8 @@ void ThreeDAnimation::update(float dt)
         //m_node->setPosition(xyz.toIrrVector());
         //m_node->setScale(scale.toIrrVector());
 
+        if (!m_playing) return;
+
         // Note that the rotation order of irrlicht is different from the one
         // in blender. So in order to reproduce the blender IPO rotations
         // correctly, we have to get the rotations around each axis and combine
diff --git a/src/graphics/irr_driver.cpp b/src/graphics/irr_driver.cpp
index 1777368d0..43decfc50 100644
--- a/src/graphics/irr_driver.cpp
+++ b/src/graphics/irr_driver.cpp
@@ -1811,14 +1811,21 @@ void IrrDriver::update(float dt)
     World *world = World::getWorld();
 
     if (GUIEngine::getCurrentScreen() != NULL &&
-             GUIEngine::getCurrentScreen()->needs3D())
+        GUIEngine::getCurrentScreen()->needs3D() &&
+        world != NULL)
     {
         //printf("Screen that needs 3D\n");
-        m_video_driver->beginScene(/*backBuffer clear*/true, /*zBuffer*/true,
-                                   video::SColor(0,0,0,255));
-        m_scene_manager->drawAll();
+        //m_video_driver->beginScene(/*backBuffer clear*/true, /*zBuffer*/true,
+        //                           video::SColor(0,0,0,255));
+        //m_scene_manager->drawAll();
+
+        if (m_glsl)
+            renderGLSL(dt);
+        else
+            renderFixed(dt);
+
         GUIEngine::render(dt);
-        m_video_driver->endScene();
+        //m_video_driver->endScene();
         return;
     }
     else if (!world)
diff --git a/src/graphics/material_manager.cpp b/src/graphics/material_manager.cpp
index 9d5cc5146..a5fea5f95 100644
--- a/src/graphics/material_manager.cpp
+++ b/src/graphics/material_manager.cpp
@@ -111,9 +111,9 @@ void MaterialManager::setAllMaterialFlags(video::ITexture* t,
 
     mb->getMaterial().ColorMaterial = video::ECM_DIFFUSE_AND_AMBIENT;
 
-    if (World::getWorld() != NULL && World::getWorld()->getTrack() != NULL)
+    if (World::getWorld() != NULL)
     {
-        mb->getMaterial().FogEnable = World::getWorld()->getTrack()->isFogEnabled();
+        mb->getMaterial().FogEnable = World::getWorld()->isFogEnabled();
     }
 
 
diff --git a/src/graphics/render.cpp b/src/graphics/render.cpp
index 3383f2eea..be6d367e1 100644
--- a/src/graphics/render.cpp
+++ b/src/graphics/render.cpp
@@ -212,7 +212,7 @@ void IrrDriver::renderGLSL(float dt)
         renderSolidSecondPass();
         PROFILER_POP_CPU_MARKER();
 
-        if (UserConfigParams::m_dynamic_lights && World::getWorld()->getTrack()->isFogEnabled())
+        if (UserConfigParams::m_dynamic_lights && World::getWorld()->isFogEnabled())
         {
             PROFILER_PUSH_CPU_MARKER("- Fog", 0xFF, 0x00, 0x00);
             m_post_processing->renderFog();
diff --git a/src/graphics/stkanimatedmesh.cpp b/src/graphics/stkanimatedmesh.cpp
index 08c40bed1..ecff6302b 100644
--- a/src/graphics/stkanimatedmesh.cpp
+++ b/src/graphics/stkanimatedmesh.cpp
@@ -253,7 +253,7 @@ void STKAnimatedMesh::render()
         for_in(mesh, TransparentMesh[TM_BUBBLE])
             drawBubble(*mesh, ModelViewProjectionMatrix);
 
-        if (World::getWorld()->getTrack()->isFogEnabled())
+        if (World::getWorld()->isFogEnabled())
         {
             if (!TransparentMesh[TM_DEFAULT].empty() || !TransparentMesh[TM_ADDITIVE].empty())
                 glUseProgram(MeshShader::TransparentFogShader::Program);
diff --git a/src/graphics/stkmesh.cpp b/src/graphics/stkmesh.cpp
index 61ab151b4..981da15b9 100644
--- a/src/graphics/stkmesh.cpp
+++ b/src/graphics/stkmesh.cpp
@@ -858,7 +858,7 @@ void initvaostate(GLMesh &mesh, TransparentMaterial TranspMat)
         break;
     case TM_DEFAULT:
     case TM_ADDITIVE:
-        if (World::getWorld()->getTrack()->isFogEnabled())
+        if (World::getWorld()->isFogEnabled())
             mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
                 MeshShader::TransparentFogShader::attrib_position, MeshShader::TransparentFogShader::attrib_texcoord, -1, -1, -1, -1, MeshShader::TransparentFogShader::attrib_color, mesh.Stride);
         else
diff --git a/src/graphics/stkmeshscenenode.cpp b/src/graphics/stkmeshscenenode.cpp
index 04c1209d0..5d64091d7 100644
--- a/src/graphics/stkmeshscenenode.cpp
+++ b/src/graphics/stkmeshscenenode.cpp
@@ -501,7 +501,7 @@ void STKMeshSceneNode::render()
         for_in(mesh, TransparentMesh[TM_BUBBLE])
             drawBubble(*mesh, ModelViewProjectionMatrix);
 
-        if (World::getWorld()->getTrack()->isFogEnabled())
+        if (World::getWorld() ->isFogEnabled())
         {
             if (!TransparentMesh[TM_DEFAULT].empty() || !TransparentMesh[TM_ADDITIVE].empty())
                 glUseProgram(MeshShader::TransparentFogShader::Program);
diff --git a/src/modes/cutscene_world.cpp b/src/modes/cutscene_world.cpp
index 53aa97d5d..606690c72 100644
--- a/src/modes/cutscene_world.cpp
+++ b/src/modes/cutscene_world.cpp
@@ -45,6 +45,8 @@
 
 #include <string>
 
+bool CutsceneWorld::s_use_duration = false;
+
 //-----------------------------------------------------------------------------
 /** Constructor. Sets up the clock mode etc.
  */
@@ -152,6 +154,9 @@ void CutsceneWorld::init()
         }
     }
 
+    if (!s_use_duration)
+        m_duration = 999999.0f;
+
     if (m_duration <= 0.0f)
     {
         Log::error("[CutsceneWorld]", "WARNING: cutscene has no duration");
@@ -367,6 +372,7 @@ void CutsceneWorld::enterRaceOverState()
 
     if (m_aborted || partId == -1 || partId == (int)m_parts.size() - 1)
     {
+        // TODO: remove hardcoded knowledge of cutscenes, replace with scripting probably
         if (m_parts.size() == 1 && m_parts[0] == "endcutscene")
         {
             CreditsScreen* credits = CreditsScreen::getInstance();
@@ -377,6 +383,14 @@ void CutsceneWorld::enterRaceOverState()
             StateManager::get()->resetAndSetStack(newStack);
             StateManager::get()->pushScreen(credits);
         }
+        // TODO: remove hardcoded knowledge of cutscenes, replace with scripting probably
+        else  if (m_parts.size() == 1 && m_parts[0] == "gpwin")
+        {
+            MainMenuScreen* mainMenu = MainMenuScreen::getInstance();
+            race_manager->exitRace();
+            StateManager::get()->resetAndGoToScreen(mainMenu);
+        }
+        // TODO: remove hardcoded knowledge of cutscenes, replace with scripting probably
         else if (race_manager->getTrackName() == "introcutscene" ||
                  race_manager->getTrackName() == "introcutscene2")
         {
@@ -417,6 +431,9 @@ void CutsceneWorld::enterRaceOverState()
  */
 bool CutsceneWorld::isRaceOver()
 {
+    if (!s_use_duration && !m_aborted)
+        return false;
+
     return m_time > m_duration;
 }   // isRaceOver
 
diff --git a/src/modes/cutscene_world.hpp b/src/modes/cutscene_world.hpp
index 2c4f7ec6c..4b35b6b70 100644
--- a/src/modes/cutscene_world.hpp
+++ b/src/modes/cutscene_world.hpp
@@ -45,18 +45,15 @@ class CutsceneWorld : public World
     double m_duration;
     bool m_aborted;
 
+    // TODO find a better way than static
+    static bool s_use_duration;
+
     /** monkey tricks to get the animations in sync with irrlicht. we reset the time
      *  after all is loaded and it's running withotu delays
      */
     bool m_second_reset;
     double m_time_at_second_reset;
 
-    void abortCutscene()
-    {
-        if (m_time < m_duration - 2.0f) m_duration = m_time + 2.0f;
-        m_aborted = true;
-    }
-
     std::vector<std::string> m_parts;
 
 public:
@@ -107,6 +104,14 @@ public:
     };
     // ------------------------------------------------------------------------
     virtual void escapePressed() OVERRIDE { abortCutscene(); }
+    // ------------------------------------------------------------------------
+    static void setUseDuration(bool use_duration) { s_use_duration = use_duration; }
+    // ------------------------------------------------------------------------
+    void abortCutscene()
+    {
+        if (m_time < m_duration - 2.0f) m_duration = m_time + 2.0f;
+        m_aborted = true;
+    }
 
 };   // CutsceneWorld
 
diff --git a/src/modes/world.cpp b/src/modes/world.cpp
index 90ba932c3..1cedb6fe4 100644
--- a/src/modes/world.cpp
+++ b/src/modes/world.cpp
@@ -1180,4 +1180,11 @@ void World::escapePressed()
     new RacePausedDialog(0.8f, 0.6f);
 }
 
+//-----------------------------------------------------------------------------
+
+bool World::isFogEnabled() const
+{
+    return m_track != NULL && m_track->isFogEnabled();
+}
+
 /* EOF */
diff --git a/src/modes/world.hpp b/src/modes/world.hpp
index d8fe1c6a6..1f88cf723 100644
--- a/src/modes/world.hpp
+++ b/src/modes/world.hpp
@@ -302,6 +302,8 @@ public:
     /** Returns a pointer to the track. */
     Track          *getTrack() const { return m_track; }
     // ------------------------------------------------------------------------
+    bool            isFogEnabled() const;
+    // ------------------------------------------------------------------------
     /** The code that draws the timer should call this first to know
      *  whether the game mode wants a timer drawn. */
     virtual bool shouldDrawTimer() const
diff --git a/src/race/race_manager.cpp b/src/race/race_manager.cpp
index cc6d34ea1..fbba422a8 100644
--- a/src/race/race_manager.cpp
+++ b/src/race/race_manager.cpp
@@ -685,8 +685,18 @@ void RaceManager::exitRace(bool delete_world)
 
         if (someHumanPlayerWon)
         {
-            StateManager::get()->pushScreen( GrandPrixWin::getInstance()  );
-            GrandPrixWin::getInstance()->setKarts(winners);
+            if (delete_world) World::deleteWorld();
+            delete_world = false;
+
+            StateManager::get()->enterGameState();
+            race_manager->setMinorMode(RaceManager::MINOR_MODE_CUTSCENE);
+            race_manager->setNumKarts(0);
+            race_manager->setNumPlayers(0);
+            race_manager->setNumLocalPlayers(0);
+            race_manager->startSingleRace("gpwin", 999, false);
+            GrandPrixWin* scene = GrandPrixWin::getInstance();
+            StateManager::get()->pushScreen(scene);
+            scene->setKarts(winners);
         }
         else
         {
diff --git a/src/states_screens/grand_prix_win.cpp b/src/states_screens/grand_prix_win.cpp
index 8af8884c4..220614e6b 100644
--- a/src/states_screens/grand_prix_win.cpp
+++ b/src/states_screens/grand_prix_win.cpp
@@ -33,8 +33,13 @@
 #include "items/item_manager.hpp"
 #include "karts/kart_properties.hpp"
 #include "karts/kart_properties_manager.hpp"
+#include "modes/cutscene_world.hpp"
+#include "modes/world.hpp"
 #include "states_screens/feature_unlocked.hpp"
 #include "states_screens/state_manager.hpp"
+#include "tracks/track.hpp"
+#include "tracks/track_object.hpp"
+#include "tracks/track_object_manager.hpp"
 #include "utils/translation.hpp"
 
 #include <IGUIEnvironment.h>
@@ -48,56 +53,54 @@ using namespace irr::core;
 using namespace irr::gui;
 using namespace irr::video;
 
-const float KARTS_DELTA_Y = 0.03f;
-const float INITIAL_Y = -3.0f;
-const float INITIAL_PODIUM_Y = -3.6f;
+const float KARTS_X = -0.62f;
+const float KARTS_DELTA_X = 0.815f;
+const float KARTS_DELTA_Y = -0.55f;
+const float KARTS_DEST_Z = 1.2f;
+const float INITIAL_Y = 0.0f;
+const float INITIAL_PODIUM_Y = -0.89f;
 const float PODIUM_HEIGHT[3] = { 0.325f, 0.5f, 0.15f };
 
 DEFINE_SCREEN_SINGLETON( GrandPrixWin );
 
 // -------------------------------------------------------------------------------------
 
-GrandPrixWin::GrandPrixWin() : Screen("grand_prix_win.stkgui")
+GrandPrixWin::GrandPrixWin() : Screen("grand_prix_win.stkgui", false)
 {
     setNeeds3D(true);
 
     m_throttle_FPS = false;
 
-    try
-    {
-        std::string path = file_manager->getAsset(FileManager::MUSIC,"win_theme.music");
-        m_music = music_manager->getMusicInformation(path);
-    }
-    catch (std::exception& e)
-    {
-        fprintf(stderr, "[GrandPrixWin] WARNING: exception caught when trying to load music: %s\n", e.what());
-        m_music = NULL;
-    }
+    m_kart_node[0] = NULL;
+    m_kart_node[1] = NULL;
+    m_kart_node[2] = NULL;
+
+    m_podium_steps[0] = NULL;
+    m_podium_steps[1] = NULL;
+    m_podium_steps[2] = NULL;
+
 }   // GrandPrixWin
 
 // -------------------------------------------------------------------------------------
 
 void GrandPrixWin::loadedFromFile()
 {
-    m_kart_node[0] = NULL;
-    m_kart_node[1] = NULL;
-    m_kart_node[2] = NULL;
-
-    m_podium_x[0] = 1.4f;
-    m_podium_z[0] = 0.0f;
-
-    m_podium_x[1] = 2.2f;
-    m_podium_z[1] = 0.5f;
-
-    m_podium_x[2] = 3.0f;
-    m_podium_z[2] = 0.0f;
 }   // loadedFromFile
 
 // -------------------------------------------------------------------------------------
 
 void GrandPrixWin::init()
 {
+    std::vector<std::string> parts;
+    parts.push_back("gpwin");
+    ((CutsceneWorld*)World::getWorld())->setParts(parts);
+    CutsceneWorld::setUseDuration(false);
+
     Screen::init();
+
+    World::getWorld()->setPhase(WorldStatus::RACE_PHASE);
+
+
     if (PlayerManager::getCurrentPlayer()->getRecentlyCompletedChallenges().size() > 0)
     {
         const core::dimension2d<u32>& frame_size = GUIEngine::getDriver()->getCurrentRenderTargetSize();
@@ -140,8 +143,6 @@ void GrandPrixWin::init()
         m_unlocked_label->m_w = message_width;
         m_unlocked_label->m_h = label_height;
         m_unlocked_label->setText(message, false);
-        //const irr::video::SColor orange(255, 255, 126, 21);
-        //unlocked_label->setColor(orange);
 
         m_unlocked_label->add();
         manualAddWidget(m_unlocked_label);
@@ -151,77 +152,8 @@ void GrandPrixWin::init()
         m_unlocked_label = NULL;
     }
 
-    m_phase = 1;
-    m_sky_angle = 0.0f;
     m_global_time = 0.0f;
-
-    video::ITexture *t = irr_driver->getTexture(FileManager::TEXTURE,
-                                                "clouds.png          ");
-    m_sky = irr_driver->addSkyDome(t,
-                                   16 /* hori_res */, 16 /* vert_res */,
-                                   1.0f /* texture_percent */,
-                                   2.0f /* sphere_percent */);
-
-    m_camera = irr_driver->addCameraSceneNode();
-    m_camera_x = 3.0f;
-    m_camera_y = 0.0f;
-    m_camera_z = -5.0f;
-    m_camera->setPosition( core::vector3df(m_camera_x, m_camera_y, m_camera_z) );
-    m_camera->setUpVector( core::vector3df(0.0, 1.0, 0.0) );
-    irr_driver->getSceneManager()->setActiveCamera(m_camera);
-
-    m_camera_target_x = 1.5f;
-    m_camera_target_z = 0.0f;
-    m_camera->setTarget( core::vector3df(m_camera_target_x, -2.0f, m_camera_target_z) );
-    m_camera->setFOV( DEGREE_TO_RAD*50.0f );
-    m_camera->updateAbsolutePosition();
-
-
-    scene::IMesh* model_village = irr_driver->getMesh( file_manager->getAsset(FileManager::MODEL,"village.b3d") );
-    assert(model_village != NULL);
-    m_village = irr_driver->addMesh(model_village);
-#ifdef DEBUG
-    m_village->setName("village");
-#endif
-    m_village->setPosition( core::vector3df(2, INITIAL_Y, 0) );
-
-
-    scene::IMesh* podium_model = irr_driver->getMesh( file_manager->getAsset(FileManager::MODEL,"wood_podium.b3d") );
-    assert(podium_model != NULL);
-
-
-    m_podium_step[0] = irr_driver->addMesh(podium_model);
-#ifdef DEBUG
-    m_podium_step[0]->setName("Podium 0");
-#endif
-    m_podium_step[0]->setPosition( core::vector3df(m_podium_x[0], INITIAL_PODIUM_Y, m_podium_z[0]) );
-
-    m_podium_step[1] = irr_driver->addMesh(podium_model);
-#ifdef DEBUG
-    m_podium_step[1]->setName("Podium 1");
-#endif
-    m_podium_step[1]->setPosition( core::vector3df(m_podium_x[1], INITIAL_PODIUM_Y, m_podium_z[1]) );
-
-    m_podium_step[2] = irr_driver->addMesh(podium_model);
-#ifdef DEBUG
-    m_podium_step[2]->setName("Podium 2");
-#endif
-    m_podium_step[2]->setPosition( core::vector3df(m_podium_x[2], INITIAL_PODIUM_Y, m_podium_z[2]) );
-
-    scene::ISceneManager* sceneManager = irr_driver->getSceneManager();
-    sceneManager->setAmbientLight(video::SColor(255, 95, 95, 95));
-
-    const core::vector3df &sun_pos = core::vector3df( 0, 200, 100.0f );
-    m_light = irr_driver->addLight(sun_pos, 300.0f, 0.25f, 0.25f, 0.25f);
-
-    m_finish_sound = sfx_manager->quickSound("gp_end");
-    if (!irr_driver->isGLSL())
-    {
-        scene::ILightSceneNode *lnode = (scene::ILightSceneNode *) m_light;
-        lnode->getLightData().DiffuseColor = irr::video::SColorf(0.25f, 0.25f, 0.25f, 1.0f);
-        lnode->getLightData().AmbientColor = irr::video::SColorf(0.25f, 0.25f, 0.25f, 1.0f);
-        lnode->getLightData().SpecularColor = irr::video::SColorf(0.0f, 0.0f, 0.0f, 1.0f);
-    }
+    m_phase = 1;
 
     sfx_manager->quickSound("gp_end");
 }   // init
@@ -231,26 +163,9 @@ void GrandPrixWin::init()
 void GrandPrixWin::tearDown()
 {
     Screen::tearDown();
-    irr_driver->removeNode(m_sky);
-    m_sky = NULL;
+    ((CutsceneWorld*)World::getWorld())->abortCutscene();
 
-    irr_driver->removeCameraSceneNode(m_camera);
-    m_camera = NULL;
-
-    irr_driver->removeNode(m_light);
-    m_light = NULL;
-
-    irr_driver->removeNode(m_village);
-    m_village = NULL;
-
-    for (int n=0; n<3; n++)
-    {
-        irr_driver->removeNode(m_podium_step[n]);
-        m_podium_step[n] = NULL;
-        if (m_kart_node[n] != NULL) irr_driver->removeNode(m_kart_node[n]);
-        m_kart_node[n] = NULL;
-    }
-    for(unsigned int i=0; i<m_all_kart_models.size(); i++)
+    for (unsigned int i = 0; i<m_all_kart_models.size(); i++)
         delete m_all_kart_models[i];
     m_all_kart_models.clear();
 
@@ -260,12 +175,14 @@ void GrandPrixWin::tearDown()
         delete m_unlocked_label;
         m_unlocked_label = NULL;
     }
-    
-    if (m_finish_sound != NULL &&
-        m_finish_sound->getStatus() == SFXManager::SFX_PLAYING)
-    {
-        m_finish_sound->stop();
-    }
+
+    m_kart_node[0] = NULL;
+    m_kart_node[1] = NULL;
+    m_kart_node[2] = NULL;
+
+    m_podium_steps[0] = NULL;
+    m_podium_steps[1] = NULL;
+    m_podium_steps[2] = NULL;
 }   // tearDown
 
 // -------------------------------------------------------------------------------------
@@ -274,11 +191,6 @@ void GrandPrixWin::onUpdate(float dt)
 {
     m_global_time += dt;
 
-    m_sky_angle += dt*2;
-    if (m_sky_angle > 360) m_sky_angle -= 360;
-    m_sky->setRotation( core::vector3df(0, m_sky_angle, 0) );
-
-
     // ---- karts move
     if (m_phase == 1)
     {
@@ -290,24 +202,27 @@ void GrandPrixWin::onUpdate(float dt)
             if (m_kart_node[k] != NULL)
             {
 
-                if (fabsf(m_kart_z[k] - m_podium_z[k]) > dt)
+                if (fabsf(m_kart_z[k] - KARTS_DEST_Z) > dt)
                 {
-                    if (m_kart_z[k] < m_podium_z[k] - dt)
+                    if (m_kart_z[k] < KARTS_DEST_Z - dt)
                     {
                         m_kart_z[k] += dt;
                     }
-                    else if (m_kart_z[k] > m_podium_z[k] + dt)
+                    else if (m_kart_z[k] > KARTS_DEST_Z + dt)
                     {
                         m_kart_z[k] -= dt;
                     }
                     else
                     {
-                        m_kart_z[k] = m_podium_z[k];
+                        m_kart_z[k] = KARTS_DEST_Z;
                     }
                     karts_not_yet_done++;
                 }
 
-                m_kart_node[k]->setPosition( core::vector3df(m_kart_x[k], m_kart_y[k], m_kart_z[k]) );
+                core::vector3df kart_pos(m_kart_x[k], m_kart_y[k], m_kart_z[k]);
+                core::vector3df kart_rot(0, m_kart_rotation[k], 0);
+                core::vector3df kart_scale(0.5f, 0.5f, 0.5f);
+                m_kart_node[k]->move(kart_pos, kart_rot, kart_scale, false);
             }
         } // end for
 
@@ -328,8 +243,16 @@ void GrandPrixWin::onUpdate(float dt)
                 if (m_kart_rotation[k] < 180.f)
                 {
                     m_kart_rotation[k] += 25.0f*dt;
-                    m_kart_node[k]->setRotation( core::vector3df(0, m_kart_rotation[k], 0) );
-                    m_podium_step[k]->setRotation( core::vector3df(0, m_kart_rotation[k], 0) );
+
+                    core::vector3df kart_pos(m_kart_x[k], m_kart_y[k], m_kart_z[k]);
+                    core::vector3df kart_rot(0, m_kart_rotation[k], 0);
+                    core::vector3df kart_scale(0.5f, 0.5f, 0.5f);
+                    m_kart_node[k]->move(kart_pos, kart_rot, kart_scale, false);
+
+                    core::vector3df podium_pos = m_podium_steps[k]->getInitXYZ();
+                    core::vector3df podium_rot(0, m_kart_rotation[k], 0);
+                    m_podium_steps[k]->move(podium_pos, podium_rot, core::vector3df(1.0f, 1.0f, 1.0f), false);
+
                     karts_not_yet_done++;
                 }
             }
@@ -349,38 +272,22 @@ void GrandPrixWin::onUpdate(float dt)
                 if (m_kart_y[k] < y_target + KARTS_DELTA_Y)
                 {
                     m_kart_y[k] += dt*(PODIUM_HEIGHT[k]);
-                    m_kart_node[k]->setPosition( core::vector3df(m_kart_x[k], m_kart_y[k], m_kart_z[k]) );
-                    m_podium_step[k]->setPosition( core::vector3df(m_podium_x[k],
-                                                                   INITIAL_PODIUM_Y - (INITIAL_Y - m_kart_y[k]) - KARTS_DELTA_Y,
-                                                                   m_podium_z[k]) );
+                    core::vector3df kart_pos(m_kart_x[k], m_kart_y[k], m_kart_z[k]);
+                    core::vector3df kart_rot(0, m_kart_rotation[k], 0);
+                    core::vector3df kart_scale(0.5f, 0.5f, 0.5f);
+                    m_kart_node[k]->move(kart_pos, kart_rot, kart_scale, false);
 
+
+                    core::vector3df podium_pos = m_podium_steps[k]->getInitXYZ();
+                    core::vector3df podium_rot(0, m_kart_rotation[k], 0);
+                    podium_pos.Y = INITIAL_PODIUM_Y - (INITIAL_Y - m_kart_y[k]) - KARTS_DELTA_Y;
+                    m_podium_steps[k]->move(podium_pos, podium_rot, core::vector3df(1.0f, 1.0f, 1.0f), false);
                 }
             }
         } // end for
 
     }
 
-    if (m_phase > 1)
-    {
-        //m_camera_x = 3.0f;
-        if (m_camera_z < -2.0f)                          m_camera_z        += dt*0.2f;
-
-        if      (m_camera_x < m_podium_x[1] - dt*0.1f)   m_camera_x        += dt*0.1f;
-        else if (m_camera_x > m_podium_x[1] + dt*0.1f)   m_camera_x        -= dt*0.1f;
-        else                                             m_camera_x         = m_podium_x[1];
-
-        if (m_camera_target_x < m_podium_x[1])           m_camera_target_x += dt*0.1f;
-
-        if (m_camera_y > -1.8f)                          m_camera_y        -= dt*0.1f;
-
-
-        m_camera->setTarget( core::vector3df(m_camera_target_x, -2.0f, m_camera_target_z) );
-
-        m_camera->setPosition( core::vector3df(m_camera_x, m_camera_y, m_camera_z) );
-        m_camera->setUpVector( core::vector3df(0.0, 1.0, 0.0) );
-        m_camera->updateAbsolutePosition();
-    }
-
 
     // ---- title
     static const int w = irr_driver->getFrameSize().Width;
@@ -413,8 +320,7 @@ void GrandPrixWin::eventCallback(GUIEngine::Widget* widget,
                 PlayerManager::getCurrentPlayer()->getRecentlyCompletedChallenges();
             PlayerManager::getCurrentPlayer()->clearUnlocked();
 
-            FeatureUnlockedCutScene* scene =
-                FeatureUnlockedCutScene::getInstance();
+            FeatureUnlockedCutScene* scene = FeatureUnlockedCutScene::getInstance();
 
             assert(unlocked.size() > 0);
             scene->addTrophy(race_manager->getDifficulty());
@@ -434,47 +340,67 @@ void GrandPrixWin::eventCallback(GUIEngine::Widget* widget,
 
 void GrandPrixWin::setKarts(const std::string idents_arg[3])
 {
+    TrackObjectManager* tobjman = World::getWorld()->getTrack()->getTrackObjectManager();
+
     // reorder in "podium order" (i.e. second player to the left, first player in the middle, last at the right)
     std::string idents[3];
     idents[0] = idents_arg[1];
     idents[1] = idents_arg[0];
     idents[2] = idents_arg[2];
 
-    for (int n=0; n<3; n++)
+    for (int i = 0; i < 3; i++)
     {
-        if (idents[n].size() == 0) continue;
+        const KartProperties* kp = kart_properties_manager->getKart(idents[i]);
+        if (kp == NULL) continue;
 
-        scene::ISceneNode* kart_main_node = NULL;
+        KartModel* kart_model = kp->getKartModelCopy();
+        m_all_kart_models.push_back(kart_model);
+        scene::ISceneNode* kart_main_node = kart_model->attachModel(false);
 
-        const KartProperties* kp = kart_properties_manager->getKart(idents[n]);
-        if (kp != NULL)
+        m_kart_x[i] = KARTS_X + i*KARTS_DELTA_X;
+        m_kart_y[i] = INITIAL_Y + KARTS_DELTA_Y;
+        m_kart_z[i] = -4; // to 1.2
+        m_kart_rotation[i] = 0.0f;
+
+        core::vector3df kart_pos(m_kart_x[i], m_kart_y[i], m_kart_z[i]);
+        core::vector3df kart_rot(0, 0, 0);
+        core::vector3df kart_scale(0.5, 0.5, 0.5);
+
+        //FIXME: it's not ideal that both the track object and the presentation know the initial coordinates of the object
+        TrackObjectPresentationSceneNode* presentation = new TrackObjectPresentationSceneNode(
+            kart_main_node, kart_pos, kart_rot, kart_scale);
+        TrackObject* tobj = new TrackObject(kart_pos, kart_rot, kart_scale,
+            "ghost", presentation, false /* isDynamic */, NULL /* physics settings */);
+        tobjman->insertObject(tobj);
+
+        m_kart_node[i] = tobj;
+    }
+
+    TrackObject* currObj;
+    PtrVector<TrackObject>& objects = tobjman->getObjects();
+    for_in(currObj, objects)
+    {
+        TrackObjectPresentationMesh* meshPresentation = currObj->getPresentation<TrackObjectPresentationMesh>();
+        if (meshPresentation != NULL)
         {
-            KartModel *kart_model = kp->getKartModelCopy();
-            m_all_kart_models.push_back(kart_model);
-            kart_main_node = kart_model->attachModel(false);
-
-            m_kart_x[n] = m_podium_x[n];
-            m_kart_y[n] = INITIAL_Y + KARTS_DELTA_Y;
-            m_kart_z[n] = -4;
-            m_kart_rotation[n] = 0.0f;
-
-            assert(kart_main_node != NULL);
-            kart_main_node->setPosition( core::vector3df(m_kart_x[n],
-                                                         m_kart_y[n],
-                                                         m_kart_z[n]) );
-            kart_main_node->setScale( core::vector3df(0.4f, 0.4f, 0.4f)  );
-            float susp[4]={0,0,0,0};
-            kart_model->update(0.0f, 0.0f, 0.0f, susp, 0.0f);
-        }
-        else
-        {
-            std::cerr << "[GrandPrixWin] WARNING : kart '" << idents[n] << "' not found!\n";
+            if (meshPresentation->getModelFile() == "gpwin_podium1.b3d")
+            {
+                m_podium_steps[0] = currObj;
+            }
+            else if (meshPresentation->getModelFile() == "gpwin_podium2.b3d")
+            {
+                m_podium_steps[1] = currObj;
+            }
+            else if (meshPresentation->getModelFile() == "gpwin_podium3.b3d")
+            {
+                m_podium_steps[2] = currObj;
+            }
         }
+    }
 
-        m_kart_node[n] = kart_main_node;
-    } // end for
-
-    assert(m_kart_node[0] != NULL || m_kart_node[1] != NULL || m_kart_node[2] != NULL);
+    assert(m_podium_steps[0] != NULL);
+    assert(m_podium_steps[1] != NULL);
+    assert(m_podium_steps[2] != NULL);
 }   // setKarts
 
 // -------------------------------------------------------------------------------------
diff --git a/src/states_screens/grand_prix_win.hpp b/src/states_screens/grand_prix_win.hpp
index 4892304e8..89079306b 100644
--- a/src/states_screens/grand_prix_win.hpp
+++ b/src/states_screens/grand_prix_win.hpp
@@ -26,6 +26,7 @@
 namespace irr { namespace scene { class ISceneNode; class ICameraSceneNode; class ILightSceneNode; class IMeshSceneNode; } }
 namespace GUIEngine { class LabelWidget; }
 class KartProperties;
+class TrackObject;
 
 /**
   * \brief Screen shown at the end of a Grand Prix
@@ -37,39 +38,27 @@ class GrandPrixWin : public GUIEngine::Screen, public GUIEngine::ScreenSingleton
 
     GrandPrixWin();
 
-    /** sky angle, 0-360 */
-    float m_sky_angle;
-
     /** Global evolution of time */
     double m_global_time;
 
-    irr::scene::IMeshSceneNode* m_village;
+    TrackObject* m_podium_steps[3];
 
-    irr::scene::IMeshSceneNode* m_podium_step[3];
-    irr::scene::ISceneNode* m_kart_node[3];
+    TrackObject* m_kart_node[3];
+
+    //irr::scene::IMeshSceneNode* m_podium_step[3];
+    //irr::scene::ISceneNode* m_kart_node[3];
 
     /** A copy of the kart model for each kart used. */
     std::vector<KartModel*> m_all_kart_models;
 
-    irr::scene::ISceneNode* m_sky;
-    irr::scene::ICameraSceneNode* m_camera;
-
-    irr::scene::ISceneNode* m_light;
-
     GUIEngine::LabelWidget* m_unlocked_label;
 
     int m_phase;
-
+    
     float m_kart_x[3], m_kart_y[3], m_kart_z[3];
-    float m_podium_x[3], m_podium_z[3];
+    //float m_podium_x[3], m_podium_z[3];
     float m_kart_rotation[3];
 
-    float m_camera_x, m_camera_y, m_camera_z;
-    float m_camera_target_x, m_camera_target_z;
-
-    MusicInformation* m_music;
-    SFXBase* m_finish_sound;
-
 public:
 
     /** \brief implement callback from parent class GUIEngine::Screen */
@@ -90,8 +79,6 @@ public:
 
     /** \pre must be called after pushing the screen, but before onUpdate had the chance to be invoked */
     void setKarts(const std::string idents[3]);
-
-    virtual MusicInformation* getMusic() const OVERRIDE { return m_music; }
 };
 
 #endif
diff --git a/src/states_screens/main_menu_screen.cpp b/src/states_screens/main_menu_screen.cpp
index 98927d034..a0cf8a5d1 100644
--- a/src/states_screens/main_menu_screen.cpp
+++ b/src/states_screens/main_menu_screen.cpp
@@ -233,17 +233,42 @@ void MainMenuScreen::eventCallback(Widget* widget, const std::string& name,
     if (selection == "options")
     {
         // The DEBUG item
+
+        // GP WIN
+        StateManager::get()->enterGameState();
+        race_manager->setMinorMode(RaceManager::MINOR_MODE_CUTSCENE);
+        race_manager->setNumKarts(0);
+        race_manager->setNumPlayers(0);
+        race_manager->setNumLocalPlayers(0);
+        race_manager->startSingleRace("gpwin", 999, false);
+        GrandPrixWin* scene = GrandPrixWin::getInstance();
+        const std::string winners[] = { "elephpant", "nolok", "pidgin" };
+        StateManager::get()->pushScreen(scene);
+        scene->setKarts(winners);
+
+        // GP Lose
+        /*
+        GrandPrixLose* scene = GrandPrixLose::getInstance();
+        StateManager::get()->pushScreen(scene);
+        std::vector<std::string> losers;
+        losers.push_back("nolok");
+        losers.push_back("elephpant");
+        losers.push_back("wilber");
+        scene->setKarts( losers );
+        */
+
+        /*
+        // FEATURE UNLOCKED
         FeatureUnlockedCutScene* scene =
-            FeatureUnlockedCutScene::getInstance();
+        FeatureUnlockedCutScene::getInstance();
 
         scene->addTrophy(RaceManager::DIFFICULTY_EASY);
         StateManager::get()->pushScreen(scene);
 
-        /*
         static int i = 1;
         i++;
 
-        if (i % 4 == 0)
+        if (i % 2 == 0)
         {
             // the passed kart will not be modified, that's why I allow myself
             // to use const_cast
@@ -255,7 +280,7 @@ void MainMenuScreen::eventCallback(Widget* widget, const std::string& name,
                                    );
             StateManager::get()->pushScreen(scene);
         }
-        else if (i % 4 == 1)
+        else if (i % 2 == 1)
         {
             std::vector<video::ITexture*> textures;
             textures.push_back(irr_driver->getTexture(
@@ -274,23 +299,6 @@ void MainMenuScreen::eventCallback(Widget* widget, const std::string& name,
             scene->addUnlockedPictures(textures, 1.0, 0.75, L"You did it");
 
             StateManager::get()->pushScreen(scene);
-        }
-        else if (i % 4 == 2)
-        {
-            GrandPrixWin* scene = GrandPrixWin::getInstance();
-            const std::string winners[] = { "elephpant", "nolok", "pidgin" };
-            StateManager::get()->pushScreen(scene);
-            scene->setKarts( winners );
-        }
-        else
-        {
-            GrandPrixLose* scene = GrandPrixLose::getInstance();
-            StateManager::get()->pushScreen(scene);
-            std::vector<std::string> losers;
-            losers.push_back("nolok");
-            losers.push_back("elephpant");
-            losers.push_back("wilber");
-            scene->setKarts( losers );
         }
          */
     }
diff --git a/src/tracks/track_object_presentation.cpp b/src/tracks/track_object_presentation.cpp
index ea5237c3e..a8ec5ef63 100644
--- a/src/tracks/track_object_presentation.cpp
+++ b/src/tracks/track_object_presentation.cpp
@@ -202,6 +202,7 @@ TrackObjectPresentationMesh::TrackObjectPresentationMesh(const XMLNode& xml_node
     std::string model_name;
     xml_node.get("model",   &model_name  );
 
+    m_model_file = model_name;
     m_is_in_skybox = false;
     std::string render_pass;
     xml_node.get("renderpass", &render_pass);
@@ -250,6 +251,22 @@ TrackObjectPresentationMesh::TrackObjectPresentationMesh(const XMLNode& xml_node
     init(&xml_node, parent, enabled);
 }
 
+TrackObjectPresentationMesh::TrackObjectPresentationMesh(
+    scene::IAnimatedMesh* model, const core::vector3df& xyz,
+    const core::vector3df& hpr, const core::vector3df& scale) :
+    TrackObjectPresentationSceneNode(xyz, hpr, scale)
+{
+    m_is_looped = false;
+    m_mesh = NULL;
+    m_node = NULL;
+
+    bool animated = (UserConfigParams::m_graphical_effects ||
+        World::getWorld()->getIdent() == IDENT_CUTSCENE);
+
+    m_mesh = model;
+    init(NULL, NULL, true);
+}
+
 TrackObjectPresentationMesh::TrackObjectPresentationMesh(
         const std::string& model_file, const core::vector3df& xyz,
         const core::vector3df& hpr, const core::vector3df& scale) :
@@ -262,6 +279,8 @@ TrackObjectPresentationMesh::TrackObjectPresentationMesh(
     bool animated = (UserConfigParams::m_graphical_effects ||
              World::getWorld()->getIdent() == IDENT_CUTSCENE);
 
+    m_model_file = model_file;
+
     if (file_manager->fileExists(model_file))
     {
         if (animated)
diff --git a/src/tracks/track_object_presentation.hpp b/src/tracks/track_object_presentation.hpp
index 469f7ce7d..561df9ff5 100644
--- a/src/tracks/track_object_presentation.hpp
+++ b/src/tracks/track_object_presentation.hpp
@@ -116,6 +116,16 @@ public:
         m_node = NULL;
     }
 
+    TrackObjectPresentationSceneNode(
+        scene::ISceneNode* node,
+        const core::vector3df& xyz,
+        const core::vector3df& hpr,
+        const core::vector3df& scale) :
+        TrackObjectPresentation(xyz, hpr, scale)
+    {
+        m_node = node;
+    }
+
     virtual const core::vector3df& getPosition() const OVERRIDE;
     virtual const core::vector3df  getAbsolutePosition() const OVERRIDE;
     virtual const core::vector3df& getRotation() const OVERRIDE;
@@ -193,6 +203,8 @@ private:
     /** End frame of the animation to be played. */
     unsigned int            m_frame_end;
 
+    std::string             m_model_file;
+
     void init(const XMLNode* xml_node, scene::ISceneNode* parent, bool enabled);
 
 public:
@@ -201,10 +213,15 @@ public:
     TrackObjectPresentationMesh(
         const std::string& model_file, const core::vector3df& xyz,
         const core::vector3df& hpr, const core::vector3df& scale);
+    TrackObjectPresentationMesh(
+        scene::IAnimatedMesh* mesh, const core::vector3df& xyz,
+        const core::vector3df& hpr, const core::vector3df& scale);
 
     virtual ~TrackObjectPresentationMesh();
 
     virtual void reset() OVERRIDE;
+
+    const std::string& getModelFile() const { return m_model_file; }
 };
 
 /**