<p><em>Det senast körda loppet placeras överst i ordningen!</em></p>
<h2>Startspår E3-finalen hingstar/valacker</h2>
<p><em>2.140 meter autostart, förstapris: 925.000 kr</em></p>
<ol>
<li>Velvet Gio (e. Nad Al Sheba) &#8211; Magnus Dahlén (1)</li>
<li>Calle Crown (e. Great Challenger) &#8211; Tomas Malmqvist (2)</li>
<li>Coin Perdu (e. S.J.&#8217;s Caviar) &#8211; Svante Båth (3)</li>
<li>Al&#8217;s Espresious (e. Prodigious) &#8211; Giuseppe Lubrano (4)</li>
<li>Twist of Fate (e. S.J.&#8217;s Caviar) &#8211; Pekka Korpi (5)</li>
<li>Van Kronos (e. Timoko) &#8211; Svante Båth (8)</li>
<li>Born Unicorn (e. Raja Mirchi) &#8211; Stefan Melander (9)</li>
<li>Lucifer Lane (e. Infinitif) &#8211; Thomas L Nilsson (12)</li>
<li>Capitol Hill (e. Muscle Hill) &#8211; Svante Båth (9)</li>
<li>Zebulon Pike (e. Zerberus) &#8211; Torbjörn Jansson (7)</li>
<li>Global Un Poco (e. Conway Hill) &#8211; Svante Båth (10)</li>
<li>Vanilla Pod (e. Muscle Hill) &#8211; Roger Walmann (11)</li>
</ol>
<h2>Startspår E3-finalen ston</h2>
<p><em>2.140 meter autostart, förstapris: 925.000 kr</em></p>
<ol>
<li>Bellatrix Zet (e. Hard Livin) &#8211; Daniel Redén (4)</li>
<li>Vanquish Kronos (e. Raja Mirchi) &#8211; Jerry Riordan (1)</li>
<li>Dibaba (e. Ready Cash) &#8211; Roger Walmann (2)</li>
<li>Vamp Kronos (e. Ready Cash) &#8211; Jerry Riordan (3)</li>
<li>Staro Lochlyn (e. Varenne) &#8211; Svante Båth (5)</li>
<li>Hanna (e. Muscle Hill) &#8211; Lutfi Kolgjini (7)</li>
<li>Drizzle C.C. (e. Sam Bourbon) &#8211; Liselotte Nyström (9)</li>
<li>Callela Lisbeth (e. Quite Easy U.S.) &#8211; Markku Nieminen (12)</li>
<li>Current Affair (e. Love You) &#8211; Tomas Malmqvist (6)</li>
<li>Sheila Laday (e. Text Me) &#8211; Peter G Norman (8)</li>
<li>Violet Bi (e. Equinox Bi) &#8211; Jim Oscarsson (10)</li>
<li>White Lightning (e. Maharajah) &#8211; Jörgen Westholms (11)</li>
</ol>
<h2>Lopp 11/Försök 5- hingstar/valacker</h2>
<p><em>Första 500m: 1.11,8 Första 1.000m: 1.15,1 Sista 500m: 1.10,1<br />
</em><strong>1 Calle Crown </strong>tog hand om ledningen och fick dämpa. Höll emot den utvändiga hästen i snabb avslutning. 1.11,5 sista varvet. <strong>6 Capitol Hill </strong>tredje invändigt. Turligt ut i andra utvändigt 700 kvar, utan rygg 350 kvar. Tog på ledaren hela vägen in till mål. <strong>4 Lucifer Lane </strong>rygg ledaren. Fast med allt sparat. 2 Tzatziki fjärde invändigt. Problem 500 kvar, kom tillbaka bra på avstånd. <strong>9 Dats Caballo</strong> tredje utvändigt. Började röra på sig 600 kvar, problem följa de bästa över upploppet. <strong>10 Hazard Boko</strong> fjärde utvändigt. Höll farten på avstånd. <strong>7 Alexander U.R.</strong> femte utvändigt. Galopperade 700 kvar. <strong>5 Neelix</strong> utvändigt ledaren. Galopperade 350 kvar. <strong>8 Kurir Brodde</strong> femte invändigt. Problem 700 kvar. <strong>2 Hard Times</strong> andra utvändigt. Galopperade 750 kvar.<br />
<strong>Sagt i vinnarcirkeln:</strong> <em>&#8221;Det var två konkurrenter som galopperade i slutkurvan och jag tog upp då jag inte ville släppa ut Lucifer Lane. Hästen förstod inte riktigt vad som gällde efter det och var lite svår att få igång igen, men jag tror inte att han var trött&#8221;</em>, sade Christoffer Eriksson.</p>
<h2>Lopp 10/Försök 5 &#8211; ston</h2>
<p><em>Första 500m: 1.11,2 Första 1.000m: 1.14,2 Sista 500m: 1.10,4</em><br />
<strong>9 Vamp Kronos</strong> tredje utvändigt. Attackerade efter 500 meter, tog över taktpinnen 1.200 meter. Ryckte i slutkurvan, joggade undan i 1.10-tempo.<strong> 7 Violet Bi</strong> fjärde utvändigt. Med i attack 700 kvar, spurtade mycket bra i vida spår utan att bli hotfull, 1.10 sista 700 meterna. <strong>1 Willow Pride</strong> frontade, släppte till favoriten 1.200 kvar. Hade svårt att haka på i tempoökningen i slutkurvan, fick maxutdelning. <strong>6 Swarovski Broline</strong> tredje utvändigt. Attackerade 700 kvar, höll bra utan att bli hotfull. <strong>3 Kashmary Night</strong> tredje invändigt. Backades loss 150 kvar, sköt till riktigt bra. Passas framöver. <strong>8 Very Many Legs</strong> femte invändigt. Ut i tredje utvändigt 600 kvar, höll farten på avstånd. <strong>5 Mogas Piggelin</strong> andra utvändigt. Frånåkt på upploppet. <strong>4 Priestess</strong> fjärde invändigt. Slagen i slutkurvan. <strong>10 MargauxAccelerator</strong> galopperade i kön efter 500 meter. <strong>2 Crowd Pleaser</strong> utvändigt ledaren. Kunde inte följa över upploppet.<br />
Sagt i vinnarcirkeln: <em>&#8221;Det gick väldigt sakta och jag litade på min hästs styrka samtidigt som jag misstänkte att de kanske kunde vilja ha rygg på henne. Hon vann väldigt enkelt och avslutade i 1.10-tempo utan att jag körde någonting på henne&#8221;</em>, sade Christoffer Eriksson.</p>
<h2>Lopp 9/Försök 4 &#8211; ston</h2>
<p><em>Första 500m: 1.10,7 Första 1.000m: 1.13,6 Sista 500m: 1.10,7</em><br />
<strong>6 Dibaba</strong> andra utvändigt. Utan rygg 500 kvar, gled förbi med lätthet när Örjan bad om lite extra. Urläcker. 1.09,8 sista 800 meterna. <strong>4 Drizzle C.C.</strong> tog hand om ledningen. Låg på friskt och höll ångan uppe. Passerad 100 kvar, mycket tapper. <strong>7 White Lightning</strong> utvändigt ledaren. Ner i vinnarhålet 500 kvar. Hakade på bra, men såg inte ut att ha något speciellt sparat. <strong>9 Flight Lane</strong> tredje utvändigt. Attackerade 500 kvar, höll farten bra i en snabb avslutning. <strong>5 Davai Westwood</strong> tredje invändigt. Dragen bakåt i slutkurvan, kom tillbaka okej på avstånd. <strong>10 Golden River</strong> fjärde utvändigt. Med i attack 700 kvar, krokade ihop med konkurrent och galopperade 300 kvar. <strong>3 Yuppie Gal</strong> rygg ledaren. Slagen 500 kvar. 8 Witty femte invändigt. Med i attack 500 kvar, ebbade ut helt. <strong>1 Xita Lavec</strong> fjärde invändigt. Krokade ihop med konkurrent och galopperade 300 kvar.<br />
<strong>Sagt i vinnarcirkeln:</strong> <em>&#8221;Det är lite slump i de här kvalloppen. Vi hade ju Caddie Lisieux med i de här loppen fjol som galopperade bort sig, men det är skönt att den här har tagit sig till final&#8221;</em>, sade ägaren Lennart Ågren.</p>
<h2>Lopp 8/Försök 4 &#8211; hingstar/valacker</h2>
<p><em>Första 500m: 1.12,6 Första 1.000m: 1.16,0 Sista 500m: 1.10,6</em><br />
<strong>4 Velvet Gio </strong>rygg ledaren som blev gratisledning efter 300 meter då två framförvarande galopperade. Fick dämpa ordentligt. Höll undan säkert i snabb avslutning. <strong>6 Van Kronos </strong>fjärde utvändigt. Attackerade 700 kvar, fick dra tåget i tredjespår. Höll mycket bra. <strong>1 Pane Vino</strong> andra utvändigt. Flyttade fram utvändigt ledaren varvet kvar. Slagen 150 kvar.<strong> 3 Mellby Fire</strong> utvändigt ledaren, avlöst varvet kvar. Loss utåt sista 100 meterna, hann ej ta något. <strong>9 Sethmikael Blanche</strong> rygg ledaren. Tappade sista 100 meterna. <strong>10 Auto Relight</strong> tredje utvändigt. Tappade mycket på upploppet. <strong>5 Busy Doin&#8217; Nothing</strong> tredje utvändigt. Tappade massor på upploppet. <strong>8 Ethien du Vivier </strong>galopperade i spetskamp efter 250 meter. Sjätte utvändigt, blev kvar i kön. <strong>7 The Bucket List F.</strong> galopperade efter 100 meter. Femte utvändigt, med i attack 700 kvar. Felade på nytt 250 kvar, såg väldigt stark ut i det skedet.<br />
<strong>Sagt från vinnarcirkeln: </strong>&#8221;<em>Vi jobbar för sådana här stunder så det är oerhört skönt för alla inblandade när vi lyckas. Hästen tävlar fortsatt med fast bomull, men det blir nog rycktussar i finalen&#8221;</em>, sade tränaren Magnus Dahlén.</p>
<h2>Lopp 7/Försök 3 &#8211; ston</h2>
<p>Första 500m: 1.08,9 Första 1.000m: 1.12,7 Sista 500m: 1.13,4<br />
<strong>10 Vanquish Kronos </strong>tredje utvändigt. Attackerade 700 kvar, ut i fjärdespår 400 kvar och svepte runt hela fältet. Läcker, men behövde bara visa 1.13 sista 700 meterna. <strong>1 Hanna </strong>tredje invändigt, ut i andra utvändigt 600 kvar. Kom ner i rygg på vinnaren vid utgången av slutkurvan. Fullföljde bra utan segerchans. <strong>7 Callela Lisbeth </strong>över i tredjespår första halvvarvet, backades ner till femte invändigt. Ut i andraspår i slutkurvan, spurtade mycket starkt i vida spår.  <strong>8 Entertainment Ås </strong>femte utvändigt. Fram i andraspår, höll farten väl. <strong>Calamara&#8217;s Girl </strong>frontade, släppte efter 500 meter. Dragen bakåt i slutkurvan, spurtade bra när luckan väl kom.  <strong>2 Alegra B. </strong>andra utvändigt som blev utvändigt ledaren efter 500 meter. Tog över ledningen 500 kvar, men var rejält stum kort senare.<strong>3 Beluga West </strong>andra utvändigt. Attackerade 600 kvar, stumt upplopp. <strong>5 Zolicia </strong>utvändigt ledaren, tog över ledningen efter 500 meter. Tvingades till tufft tempo, stannade helt 500 kvar. <strong>6 Regina Brodda </strong>fjärde invändigt. Frånåkt. <strong>9 Exit Light </strong>fjärde utvändigt. Med i attack 700 kvar, galopperade in mot upploppet.<br />
<strong>Sagt i vinnarcirkeln: </strong><em>&#8221;Hon är väldigt snabb i benen och nu hade hon dessutom fått två lopp i kroppen. De andra körde ju så tufft så de var möra när vi kom&#8221;, </em>sade Christoffer Eriksson.</p>
<h2>Lopp 6/Försök 3 &#8211; hingstar/valacker</h2>
<p><em>Första 500m: 1.11,7 Första 1.000m: 1.12,1 Sista 500m: 1.19,0<br />
</em><strong>7 Al&#8217;s Espresious </strong>andra utvändigt. Flyttade fram utvändigt ledaren varvet före mål. Kopplade grepp 200 kvar. Var rejält mörr och närmast skrittade i mål, räddades av linjen. <strong>1 Zebulon Pike </strong>höll upp ledningen. Släppte efter 750 meter. Ut i rygg på vinnaren 200 kvar, attackerade 100 kvar och hann sånär förbi i långsam avslutning. <strong>5 Summer Wein </strong>rygg ledaren. Tog sig ut på första långsidan i takt situation, tog över ledningen efter 750 meter. Låg på friskt och gick på i hög fart. Rejält trött 150 kvar. <strong>8 Isla de Pinos </strong>utvändigt ledaren. Backades ner i tredje invändigt efter 800 meter för att åter ta andra utvändigt 1.100 kvar. Tappade på upploppet. <strong>10 Ergo Am </strong>tredje utvändigt. Slagen 500 kvar. <strong>6 Vainqueur R.P. </strong>fjärde utvändigt. Mycket nära galopp 800 kvar, testade i tredjespår, galopperade 600 kvar. <strong>3 U.B.Cool </strong>galopperade innan start. <strong>2 Lovely Vacation</strong> galopperade innan start. <strong>4 Speedy Face </strong>startgalopp.<br />
<strong>Sagt i vinnarcirkeln: </strong><em>&#8221;Jag har gjort allt med den här lilla hästen; det är det här man jobbar för. Det är som Johnny sade att hästen är alltjämt en bebis, men jag har hela tiden sagt att han kommer bli mycket bättre nästa år. Det ska bli kul att följa hans utveckling och jag hoppas att de här två veckorna går fort fram till finalen&#8221;</em>, sade tränaren Giuseppe Lubrano.</p>
<h2>Lopp 5/Försök 2 &#8211; hingstar/valacker</h2>
<p><em>Första 500m: 1.11,2 Första 1.000m: 1.13,8 Sista 500m: 1.11,1<br />
</em><strong>5 Coin Perdu</strong> aningen generad efter 100 meter, togs piano runt första kurvan. Gled fram utvändigt ledaren, tog över efter 600 meter. Fick konkurrent på utsidan per omgående, men lämnade med lätthet sista 100 meterna. Tillsynes obrukad via 1.12 sista 700 meterna. <strong>8 Born Unicorn </strong>andra utvändigt som blev utvändigt ledaren efter 700 meter. Höll ställningarna på utsidan tills 100 kvar, mycket bra! <strong>1 Vanilla Pod </strong>rygg ledaren som blev gratisledning efter 250 meter. Släppte 1.500 kvar. På väg backas ut i andra utvändigt 300 kvar, men gick tillbaka invändigt. Kunde inte haka på sista 100 meterna. <strong>6 Gilbert Bris </strong>andra utvändigt. Problem 400 kvar, tappade. <strong>2 Castleman </strong>tredje invändigt. Tappade på upploppet. <strong>9 Free to Party </strong>tredje utvändigt. Tappade på upploppet. <strong>7 Kiss me Tooma </strong>fjärde utvändigt. Rejält frånåkt i spurten. <strong>3 Casterly Rock </strong>galopperade direkt. <strong>4 Exquisite Sisu </strong>frontade, galopperade efter 250 meter.<br />
<strong>Sagt från vinnarcirkeln: </strong><em>&#8221;För att vara på den här nivån måste man ha många saker. Coin Perdu har tekniken, hårdheten, lungkapaciteten, inställningen och hårdheten. Framförallt känns han väldigt stark och jag har aldrig känt botten i honom. Han gick med skor idag, men barfota senast i Sundsvall och kändes ruskigt bra på den balansen som det också kommer bli i finalen&#8221;</em>, sade Erik Adielsson.</p>
<h2>Lopp 4/Försök 2 &#8211; ston</h2>
<p><em>Första 500m: 1.12,3 Första 1.000m: 1.15,6 Sista 500m: 1.13,1</em><br />
<strong>6 Bellatrix Zet</strong> tredje utvändigt. Fram ett hack 650 kvar, attackerade 250 kvar. Bet i bra och kopplade grepp i sista steget. <strong>3 Current Affair</strong> utvändigt ledaren, släpptes till tät efter 450 meter. Utmanad sista 100 meterna, gav sig väl enkelt om än med knapp marginal. 1.13,8 sista varvet. <strong>5 Samantha As</strong> frontade, släppte efter 450 meter. Loss sista 50 meterna, föga brukad i mål. <strong>1 Shestheone Trot</strong> utvändigt ledaren. Låg på friskt. Slagen 100 kvar. <strong>4 Calissa Rich</strong> fjärde invändigt. Andraspår i rygg 200 kvar, höll farten väl. <strong>11 Econic</strong> fjärde utvändigt. Tappade på upploppet. <strong>2 Ensemble Am</strong> tredje invändigt. Galopperade 700 kvar. <strong>8 Hope</strong> femte invändigt. Galopperade 700 kvar. <strong>9 Run Chica Run</strong> andra utvändigt. Galopperade 650 kvar. <strong>10 Hevin Boko</strong> galopperade efter 100 meterna.<br />
<strong>Sagt i vinnarcirkeln:</strong> <em>&#8221;Jag var lite optimistisk i tanken om att vi skulle kunna gå till final, men är ändå överraskad över att vi vann loppet. Hästen har utvecklats enormt och framförallt blivit snabbare sedan skorycket. Det har gett en växel till och jag tror hon kommer vara ännu bättre i finalen&#8221;</em>, sade Kenneth Haugstad.</p>
<h2></h2>
<h2>Lopp 3/Försök 1 &#8211; hingstar/valacker</h2>
<p><em>Första 500m: 1.11,9 Första 1.000m: 1.14,7 Sista 500m: 1.10,8</em><br />
<strong>5 Twist of Fate </strong>snabbstartade till ledningen. Rejält ansatt sista 700 meterna. Började se mör ut 300 kvar, men höll stången. <strong>2 Global Un Poco </strong>utvändigt ledaren. Stred storstilat hela vägen in till linjen. <strong>9 Diamonds Lucky </strong>tredje invändigt, fram ett hack efter 750 meter. Tappade på tätduon över upploppet, tog max. <strong>6 Young da Vici </strong>andra utvändigt. Problem 300 kvar, kom tillbaka något sista 100 meterna. <strong>4 Yeezuz </strong>fjärde utvändigt efter startgalopp. Ner i tredje invändigt 700 kvar. Tappade på upploppet, 1.13,5 sista 1.900 meterna. <strong>7 M.T.Machiavelli</strong> fjärde invändigt. Störd av galopperande konkurrent 800 kvar, bra tillbaka. <strong>1 R.H.Garanti </strong>tredje invändigt, galopperade efter ett halvvarv. <strong>3 Espoir de Ginai </strong>galopperade direkt. <strong>10 Soulmate Face </strong>tredje invändigt. Galopperade 800 kvar. <strong>8 Vagabond Vik </strong>tredje utvändigt. Attackerade 250 kvar, galopperade kort senare. Såg ut att ha mycket sparat i det skedet.<br />
<strong>Sagt i vinnarcirkeln: </strong><em>&#8221;Hästen gick bra idag. Vi förlorade ju senast, men då fick vi inte ledningen. Jag tycker att hästen kändes ännu bättre idag. Det är ju en ung häst så förhoppningsvis ska han bara bli bättre och bättre&#8221;</em>, sade Pekka Korpi.</p>
<h2>Lopp 2/Försök 1 &#8211; ston</h2>
<p><em>Första 500m: 1.15,0 Första 1.000m: 1.17,9 Sista 500m: 1.11,5</em><br />
<strong>6 Staro Lochlyn</strong> andra utvändigt. Gav sig iväg så fort tempot sjönk, övertog ledningen 1.500 kvar. Gick undan enkelt i lite flegmatisk stil. <strong>5 Sheilah Laday</strong> utvändigt ledaren. Höll farten starkt utan att bli riktigt hotfull. <strong>3 Electrical</strong> frontade, släppte på första långsidan. Togs ut i andra utvändigt 600 kvar, höll farten bra. <strong>8 Helloise Boko</strong> femte utvändigt. Attackerade varvet kvar, fick gå merparten av resterande del utan draghjälp. Höll tills 100 kvar. <strong>7 Endora du Busset</strong> fjärde invändigt. Fast i trött rygg, tillsynes okörd. <strong>11 Fine Lane </strong>fjärde utvändigt. Satt kvar på sista bortre långsidan, spurtade godkänt i vida spår utan chans. <strong>1 Kiss Me Tooma</strong> femte invändigt efter startgalopp. Utåt i banan på upploppet, fullföljde positivt. <strong>2 Butterfly Ima</strong> tredje invändigt. Galopperade 150 kvar. <strong>9 Hillcrest Player </strong>tredje utvändigt. Attackerade 800 kvar, galopperade 600 kvar. <strong>10 Saranda Face</strong> andra utvändigt. Galopperade 750 kvar på väg mot attack. <strong>4 Romance Amok</strong> galopperade direkt.<br />
<strong>Sagt i vinnarcirkeln:</strong> <em>&#8221;Hon är tacksam den här; en jättefin häst. Jag var jättenöjd med det hon gjorde idag även om hon var frånvarande första 100 meterna och inte alls förstod vad hon skulle göra&#8221;</em>, sade segerkusken Erik Adielsson.</p>
<h2></h2>
