<p><strong>Lopp 10, Norskt Travderby, förstapris: 1.000.000 NOK</strong></p>
<p>– Jag har aldrig varit så så säker på att vinna ett Derby som jag är just nu.</p>
<p>Jan Kristian Waaler satte färg på förhandssnacket inför det norska Derbyt i samband med spårlottningen och så rätt han fick! På förhand hade man tydliggjort att man skulle köra i ledningen med <strong>Cokstile </strong>(e. Coktail Jet) och Lars Anvar Kolle höll också fast vid den taktiken.</p>
<p>I en ursinnig kamp gentemot <strong>Ferrari B.R. </strong>(e. Muscles Yankee) hölls innerspåret och ledningen upp. Det gick så pass fort att Ferrari B.R. inte klarade av att hålla ordningen på sina ben utan slog på en galopp och fick backas ner i djup köposition.</p>
<figure id="attachment_12096" aria-describedby="caption-attachment-12096" style="width: 2000px" class="wp-caption alignleft"><img class="size-full wp-image-12096" src="https://sulkysport.se/wp-content/uploads/2017/09/cokstile2web.jpg" alt="" width="2000" height="1080" /><figcaption id="caption-attachment-12096" class="wp-caption-text">En rörd tränare Jan Kristian Waaler tillsammans med bland andra ägaren Jan-Erik Andresen och kusken Lars Anvar Kolle efter Derbysegern. Foto Roger Svalsröd/Hesteguiden.com</figcaption></figure>
<p>Cokstile kom till första halvvarvet på 1.10,3, varvet på 1.14,2 och det var just jämnt 1.14-tempo som loppet blev kört i resterande del. De första två varven nåddes på 1.14,1 och första attacken kom på sista bortre långsidan.<br />
Då var det Björn Goop som gav sig iväg med fjolårets Kriterievinnare <strong>Shocking Superman </strong>(e. Orlando Vici) från andra utvändigt. Dödenstravande <strong>Born In The U.S.A. </strong>(e. Muscle Hill) blev rundad 400 meter före mål och med där i draget kom <strong>Evil Enok M.E. </strong>(e. Magnetic Power).<br />
Det var Cokstile, Shocking Superman och Evil Enok M.E. det skulle stå emellan och Shocking Superman var faktiskt förbi Cokstile 150 meter före mål.</p>
<p>Då tog Cokstile fram löpskallen likt Cyber Lane gjorde i det svenska derbyt, kontrade och höll undan för Lars Anvar Kolle. Det på segertiden 1.13,4a/2.600 meter vilket får anses vara en toppnotering i vätan på Bjerke.</p>
<p>– Vi körde vad som gick båda två i första kurvan. När Ferrari kotade över blev det lite lugnare, men en sådan öppning sätter sina spår. Hela sista 500 meterna kände jag mig egentligen slagen, men den här hästen har ett hjärta av guld. En toppindivid som är enkel att köra; alla kuskars dröm, sade Lars Anvar Kolle.</p>
<p>Tränaren Jan Kristian Waaler tog sin andra Derbyseger i och med Cokstiles triumf.<br />
– Det här är stort. Jag har tänkt på det här loppet sedan ifjol då jag var för snäll mot honom inför Kriteriet. Det tog vi igen nu, sade Waaler.</p>
<h2>&#8221;Lät i halsen&#8221;</h2>
<p>Desto mindre muntert var det fullt förståeligt hos Per Oleg Midtfjeld. Ferrari B.R. var geistlös loppet igenom och Momarken-tränaren verkade påtagligt bekymrad efteråt.</p>
<p>– Han kotade över i första kurvan. Där blev det fel, men han var svag för dagen oavsett och hade inte haft med utgången att göra. Det som oroar mig mest är att det var ljud i halsen på honom idag; det har han aldrig haft förut, sade Midtfjeld till Rikstoto Direkte.</p>
<p>Björn Goops Shocking Superman höll alltså till andraplatsen. Ett resultat Gopp verkade klart nöjd med efter loppet.</p>
<p>– Det kändes bra in mot upploppet, men jag såg att ledaren inte var trött. Jag trodde att vi skulle hålla en bit, men jag är jättenöjd med hästens insats. Om det norska derbyt var bättre än det svenska? Ja, det var i alla fall inte sämre. De norska fyraåringarna håller riktigt hög klass och absolut hade Cokstile kunnat vinna det Svenska Derbyt också som han var idag, sade Goop.</p>
<div class="factbox full minify">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									RESULTAT NORSKT TRAVDERBY								</h3>
<div class="content">
<p>Prispengar: 1.000.000-500.000-280.000-175.000-125.000-75.000-(5.000 NOK till övriga icke diskvalificerade hästar)</p>
<ol>
<li>Cokstile (e. Quite Easy U.S.) &#8211; Lars Anvar Kolle (Jan Kristian Waaler) &#8211; 1.13,4</li>
<li>Shocking Superman (e. Orlando Vici) &#8211; Björn Goop &#8211; 1.13,4</li>
<li>Evil Enok M.E. (e. Magnetic Power) &#8211; Noralf P Braekken &#8211; 1.13,4</li>
<li>Born in the U.S.A. (e. Muscle Hill) &#8211; Eirik Höitomt (Nora Udjus Hansen) &#8211; 1.13,5</li>
<li>Cheif Orlando (e. Orlando Vici) &#8211; Frode Hamre &#8211; 1.13,5</li>
<li>C.C.Nosto (e. Thai Tanic) &#8211; Hans Christian Holm (Steinar Holm) &#8211; 1-13,6</li>
</ol>
<p>Oplacerade: Looking Superb 1.13,9, Derby d&#8217;Estino 1.14,0, Allaway G.T. 1.14,6, N.U.Coeur de Soleil 1.14,6, Ferrari B.R. 1.14,8g, Jetsun 1.24,1.</p>
</p></div>
</p></div>
</p></div>
</p></div>
<div class="expand">
						<span class="text">Expandera</span><br />
						<span class="icon sprites"></span>
					</div>
</p></div>
</p></div>
<p><strong>Lopp 8, Norskt Travkriterium, förstapris: 750.000 NOK</strong></p>
<p>Svensk seger! Ola Åsebös <strong>Hard Times </strong>(e. Coktail Jet) har gått ifrån att i princip vara okänd på norsk mark till att vara landets bästa treåring. Efter den övertygande segern bakifrån i försöksloppet så bar det nu till ledningen istället i lag med Ulf Ohlsson och därifrån var hästen aldrig nära att förlora.</p>
<p>Initialt frontade Geir Vegard Gundersen med <strong>Gretzky B.R. </strong>(e. Quite Easy U.S.), släppte till stallkamraten <strong>Black Talisman </strong>(e. Sam Bourbon) efter 400 meter vilken överlät taktpinnen till Hard Times 200 meter senare.</p>
<figure id="attachment_12082" aria-describedby="caption-attachment-12082" style="width: 2000px" class="wp-caption alignleft"><img class="size-full wp-image-12082" src="https://sulkysport.se/wp-content/uploads/2017/09/hardtimesweb1.jpg" alt="" width="2000" height="1080" /><figcaption id="caption-attachment-12082" class="wp-caption-text">Bergsåkeramatören Ola Åsebö efter Hard Times seger i norska Kriteriet. Foto Morten Skifjeld/Hesteguiden.com</figcaption></figure>
<p>Varvet gick så pass fort som 1.13,1, men det spelade ingen roll. När Frode Hamre skickade iväg favoriten <strong>Vainqueur R.P. </strong>(e. Infinitif) på sista bortre långsidan från tredje utvändigt kunde man lätt tro att han skulle svepa fram till dödens på 100 meter, men istället tappade hästen stilen.</p>
<p>Frågan är dock om det spelade någon roll. Hard Times spänstade bara ifrån sina konkurrenter över upploppet och vann åkandes på 1.13,4a/2.100 meter.</p>
<p>I och med att han var anmäld till Premiechansen dubblerade han förstapriset till 1,5 miljon norska kronor!</p>
<p>– Jag fick bilder på hästen av uppfödaren och gillade linjerna. Jag blev dock lite besviken första gången jag såg honom, men det har gått över nu. Det här känns helt otroligt; det såg ut som att han hade fulla linor hela vägen, sade Bergsåkersamatören Ola Åsebö.</p>
<p>Black Talisman höll farten godkänt i rygg till andraplatsen, <strong>Ghazi B.R. </strong>(e. Cantab Hall) höll till tredjeplatsen från dödens för Tom Erik Solberg och Vainqueur R.P. kom tillbaka helt okej som fyra.</p>
<p>– Jag är besviken. Han var nära att galoppera 800 kvar och var inte lika fin som i kvalet. Jag tror att banan som blivit hård efter regnet påverkade honom negativt, men vi inte skylla på något. Vinnaren var väldigt bra, sade Frode Hamre till TV12.</p>
<p><strong>Lopp 4, Norskt Travderby &#8211; ston, förstapris: 500.000 NOK</strong></p>
<p>Uppstickaren <strong>Madelen L.T.C. </strong>(e. Thai Tanic) mådde onekligen bra av att genrepa inför Derbystoet med att sluta femma i Treasure Kronos världsrekordlopp på Solvalla.</p>
<p>Då stod hon på start och var &#8221;bara&#8221; femma, men i Norskt Travderby för ston blev det full pott. Efter tredjeplatsen i stoavdelningen av Jarlsberg Grand Prix och den övertygande försökssegern hade Marius och Eirik Höitomts häst fina förutsättningar med innerspår bakom bilen. Förutsättningar som hon också utnyttjade.</p>
<p>Eirik Höitomt fick Thai Tanic-dottern till att hålla upp täten och där skulle han bestämt köra. Björn Goop styrde fram på hans utsida i andra kurvan med <strong>Fortuna B.R. </strong>(e. Donato Hanover), men stoet tappade stilen och galopperade 1.200 meter före mål.</p>
<p>Då gjorde istället Geir Vegard Gundersen slag i saken och sände fram favoriten <strong>Nice Eleven L. </strong>(e. Coktail Jet). Hon sällskapade på Madelen T.L.C.:s utsida hela slutvarvet och såg stark ut vid utgången av slutkurvan. Däremot kom inte den där riktiga överväxeln från Geir Vegard Gundersens häst när han drog ner det norska huvudlaget 200 meter före mål utan Madelen L.T.C. kunde hålla sin halva längd hela vägen in till mål.</p>
<p>Segertiden skrevs till 1.13,3a/2.100 meter och förstapriset var 500.000 norska kronor.</p>
<p>För Kriterie- och Derbyvinnaren Thai Tanic kom nu hans första segrande avkomma i Klasselöpsfinalerna.</p>
<p>Höitomt kunde även räkna in tredjeplatsen då Marius styrde in <strong>Lady Lane </strong>(e. Mr Commissioner) till den placering efter en resa som fyra i andraspår.</p>
<p><strong>Lopp 2, Norskt Travkriterium, förstapris: 375.000 NOK</strong></p>
<p>Gunnar Eggen må ha avslutat sin körsvenskarriär, men träna häst kan han alltjämt! I söndagens första klassiska, unghästfinal för varmblod kunde Gunnar se sonen Hans Jörgen Eggen vinna med <strong>Gluhwein </strong>(e. Weingartner) i hennes blott femte start i karriären.</p>
<figure id="attachment_12062" aria-describedby="caption-attachment-12062" style="width: 2000px" class="wp-caption alignright"><img class="size-full wp-image-12062" src="https://sulkysport.se/wp-content/uploads/2017/09/gluhweinweb.jpg" alt="" width="2000" height="1080" /><figcaption id="caption-attachment-12062" class="wp-caption-text">Hans Jörgen Eggen överraskade i Stokriteriet med Gluhwein. Foto Roger Svalsröd/Hesteguiden.com</figcaption></figure>
<p>När favoriten <strong>Normandie Royal </strong>(e. Orlando Vici) släpptes till tät efter 600 meter av <strong>Calina </strong>(e. Archipelago) trodde nog de flesta att loppet var över.<br />
Hugo Langeweg Jr höll dock ett anständigt tempo på loppet och nådde varvet på 1.13,9 efter att &#8221;halvan&#8221; gått på 1.12,1.</p>
<p>Frode Hamre skiftade tredje invändigt mot dödspositionen när 1.200 meter återstod bakom <strong>Thai Sarahya </strong>(e. Broadway Hall) och det syntes i mitten av slutkurvan när farten ökade ytterligare att han hade grepp om ledarinnan som kastade in handduken och blev utan prispengar.</p>
<p>Den tunga löpningen Thai Sarahya hade fått satte dock sina spår. När Hans Jörgen Eggen vek ut Gluhwein för attack från andra utvändigt bet det bra och 29-oddsaren hade inga problem att avgöra per omgående.</p>
<p>Där bakom fick istället Sigbjörn Kolnes-tränade <strong>Let&#8217;s Take A Selfie </strong>(e. Ens Snapshot) luckan från tredje invändigt och sköt till vasst, men något riktigt hot blev hon aldrig.</p>
<p>Calina hakade på okej som trea via vinnarhålet medan Thai Sarahya höll till fjärdeplatsen.</p>
<p>Segertiden skrevs till 1.14,7a/2.100 meter och eftersom Gluhwein var premiechansad dubblerade hon förstapris och fick 750.000 norska kronor.</p>
<p>– Jag kände i slutkurvan att hon hade väldigt mycket krafter kvar, men hela sin karriär har hon haft en tendens att bryta ut i kurvorna. Hur detta känns? Det går inte beskriva; ring mig i morgon så ska jag beskriva känslan, sade Hans Jörgen Eggen som körde sin första klasselöpsfinal enligt Trav og Galoppnytt.</p>
<p>Gluhwein har ett känt syskon i den femårige <strong>Malkin N.O. </strong>(e. Ken Warkentin). I Jan Kristian Waalers regi har hästen sprungit in 753.050 norska kronor och tagit rekordet 1.11,6.</p>
<p>Björn Goops <strong>Easy Creation </strong>(e. Quite Easy U.S.) galopperade I spetskörningen efter 250 meter.</p>

Fokustema
Bjerke söndag varmblod
Läs senare
Cokstile vann Norskt Travderby
Här uppdaterar vi de fyra varmblodsfinalerna som avgörs idag på Bjerke, lopp för lopp.
