
<p class="has-drop-cap">1Hästägare hos Per Oleg Midtfjeld köpte svenskfödde <strong>Steinlager</strong> (e. Good As Gold-Keystone Jazzy) som ostartad på sommaren som treåring från Jörgen Westholm och Midtfjeld utvecklade honom till en världsstjärna.<br>– Det är en resa som jag aldrig glömmer och Elitloppsvinsten smäller förstås allra högst, men allt runt Steinlager var ett enda stort äventyr, har Per Oleg berättat för Sulkysport.</p>



<p>Ja, Steinlager hade en minst sagt strålande tävlingskarriär, där 88 starter (35–15–12) inbringade över 13,2 miljoner kronor. Vid segern i Elitloppsfinalen 2005 satte han sitt rekord 1.10,0a/1.609 meter.<br>2005 var Steinlagers främsta år. Då vann han de största loppen för äldre i de tre skandinaviska länderna genom att förutom Elitloppet även plocka hem Copenhagen Cup och Oslo Grand Prix. Steinlager vann även Åby Stora Pris 2004 och tog dubbla triumfer i Årjängs Stora Sprinterlopp för att nämna några ytterligare segrar.</p>



<p>Efter fjärdeplatsen i Elitloppet 2006 skadades Steinlager och karriären verkade vara över, men efter två års uppehåll gjorde Steinlager ytterligare en säsong, som tioåring, i Olle Goops regi.</p>



<p>Steinlager fick också ett eget hyllningslopp på gamla hemmabanan Momarken 2007, då Lutfi Kolgjini med <strong>Vamos</strong> (e. Niton) tog sin första av fyra tränarsegrar i loppet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/05/kolgjinilutfisulky-617x333.jpg" alt="" class="wp-image-91472"/><figcaption class="wp-element-caption">Lutfi Kolgjini. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p><strong>Snabbaste vinnarna av Steinlagers Äreslopp</strong></p>



<p><em>År, häst (far) – Körsven (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2019 <strong>Cokstile</strong> (e. Quite Easy) – Lars Anvar Kolle (Jan Kristian Waaler) – 1.11,0a</li>



<li>2017 <strong>Mosaique Face </strong>(e. Classic Photo) – Adrian Kolgjini (Lutfi Kolgjini) – 1.11,7a</li>



<li>2016 <strong>Donna di Quattro</strong> (e. Love You) – Björn Goop (Tomas Malmqvist) – 1.11,8a</li>



<li>2018 <strong>Sir Ratzeputz</strong> (e. Love You) – Björn Goop (Timo Nurmos) – 1.11,9a</li>
</ul>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">2Av 15 upplagor av Steinlagers Äreslopp har hela tolv gått till svensktränade hästar. Ifjol var det Årjängsamatören Helena Edlunds <strong>Beartime</strong> (e. Pastor Stephen) och Carl Johan Jepson som slog till i sitt första möte med den äldre eliten.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/06/stoletheshowhesteguiden-617x333.jpg" alt="" class="wp-image-314208"/><figcaption class="wp-element-caption">Stoletheshow och Frode Hamre vid segern i Oslo Grand Prix 2022. Foto Anders Kongsrud/Hesteguiden.com</figcaption></figure>



<p>Nu står det stora hoppet om norsk seger till Frode Hamre-tränade årsdebutanten <strong>Stoletheshow</strong> (e. Dream Vacation), som hade en toppsäsong förra året med nästan fem miljoner kronor insprunget. Segern i Oslo Grand Prix och andraplatsen i Hugo Åbergs Memorial fanns bland topparna.<br>– Vi har fått bästa spåret och om jag hade valt hade jag tagit spår två. Han är bra förberedd, har gått sina jobb och är fräsch och fin och på gott humör. De största loppen ifjol vann han från ledningen, men har gjort bra lopp bakifrån också som i Hugo Åbergs. Han klarar det också, men är bäst i ledningen. Om vi har ambitioner att vara med i de största loppen, så ska han klara den här uppgiften, sade Frode Hamre till V65 Direkt.</p>



<p><a href="https://sulkysport.se/spelstugan/v75-tips-momarken-18-mars/" target="_blank" rel="noreferrer noopener">––> Vad tror Sulkysports tipsexpert om Stoletheshows möjligheter= Här är stora tipsgenomgången till V75.</a></p>



<p>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</p>



<p><a href="https://www.atg.se/andelskungen/spel/206687_V75_2023-03-18_80_5">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206688_V75_2023-03-18_80_5">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206689_V75_2023-03-18_80_5">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<p>På svensk mark blir det breddlopptävlingar i Halmstad (första start 11.10) denna lördag.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/03/230318.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">3Pekka Korpis <strong>Magical Princess</strong> (e. Maharajah) gjorde rent hus I de finska tre- och fyraåringsloppen och nådde över 100.000 euro intjänat som femåring efter en andraplats i finalen av Suur Hollola-Ajo.</p>



<p>Det loppet avgjordes den 3 juli och sedan dess har inte stoet varit synlig i tävlingssammanhang, men idag är hon redo för comeback.<br>Den sker i ett renodlat stolopp inom Vermos finska V75-omgång med Antti Teivainen som kusk och bland deltagarna syns även hennes helsyster <strong>Magic Madonna</strong> (e. Maharajah) som nu gör sin första start som femåring.</p>



<p>Förstapriset är 12.000 euro.</p>



<p><strong>Startlista Espoon Palkinto, 2.120 meter autostart:</strong></p>



<ol class="wp-block-list">
<li>Gal Gadot Racing – Niko Jokela</li>



<li>Magic Madonna – Ilkka Korpi</li>



<li>Tour Knight – Jarmo Saarela</li>



<li>El Indeed – Hannu Torvinen</li>



<li>Club Nord Elit – Tapio Perttunen</li>



<li>Sahara True Lies – Tommi Kylliäinen</li>



<li>Endless Story – Santtu Raitala</li>



<li>Willow Pride – Ari Moilanen</li>



<li>True Devotion – Jukka Torvinen</li>



<li>Ice Wine – Iika Nurmonen</li>



<li>Magical Princess – Antti Teivainen</li>
</ol>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">4Gävletravet presenterar en ny proffstränare <a href="https://www.gavletravet.se/arkiv/nyhetsarkiv/20232/mars/caroline-johncke-ny-a-tranare/" target="_blank" rel="noreferrer noopener">på banans hemsida</a>. Caroline Jöhncke, 44, tar steget från amatör till proffs och inleder med sju hästar på träninglistan. En av dessa är åttaårige <strong>Ajusco</strong> (e. One Too Many), 1.11,6am*/622.800 kr, som ordnade Carolines största seger hittills som tränare när han sommaren 2021 vann en klass I-final.</p>



<p>Annars har Caroline en bakgrund inom ridsporten, där hon sysslade med hopphästar under många år.<br>– Jag var med om en olycka och bröt benet 2016, vilket gjorde att jag inte kunde fortsätta rida, så vi fick sälja alla hopphästar utom en som vi har kvar. Vi hade rehab-hästar hemma hos oss och tack vare det blev jag mer involverad i våra travhästar. Jag utbildade mig mer och mer och förra året gick jag klart proffstränarkursen, på den vägen är det, säger hon till Gävletravets hemsida.</p>



<p>Verksamheten bedrivs på en gård i Oppala en mil från Gävletravet, som köptes i höstas och där förfogar hon över tolv boxar.<br>– Det finns en slinga på 1,5 km och på den har vi gjort en rakbana på 500 meter. Framöver är tanken att det även ska byggas en sandbana. Vi har även tillgång till en stor ridbana, säger Caroline.</p>



<p class="has-text-align-center">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/04/6a240faa59c54f57b818f7864e614692-617x823.jpg" alt="" class="wp-image-284197"/><figcaption class="wp-element-caption">Bythebook. Foto Privat</figcaption></figure>



<p class="has-drop-cap">5Svenskfödde <strong>Bythebook</strong> (e. Googoo Gaagaa) tog planenligt sin tredje raka seger på italiensk mark under fredagseftermiddagen. Den forne vinnaren av Svensk Uppfödningslöpning startade från 20 meters tillägg i sprinterloppet Premio Renee Newton (€5.500) på La Maura-banan i Milano och fick jobba på ledarens utsida under slutrundan, men det spelade ingen som helst roll.</p>



<p>Bythebook gick undan till vinst med fyra längder på 1.12,8/1.670 meter och är alltjämt obesegrad detta år. Precis som vid de tidigare segerloppen så var det hans tränare Alessandro Gocciadoro som körde hästen till vinst.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">6Det travas på fyra travbanor i Frankrike denna lördag och på två av dem finns det blågula intressen. Till gräsbanan i Saumur (första start 14.30) drygt 30 mil sydväst om Paris sänder Jörgen Westholm två hästar för start i samma lopp.</p>



<p>Såväl Hans R Strömberg-ägde <strong>Haxo d’Avignere</strong> (e. Niky) som Westholms egenägda <strong>Holster</strong> (e. Bird Parker) syns i Prix Louis de Grenelle (€16.000) och faktum är att Westholm även har en koppling till kvällens svenskhopp på Vivaux-banan i Marseille (första start 18.45).</p>



<p>Där startar nämligen David Cinier <strong>Viscount</strong> (e. From Above) i montéloppet Prix de la Piboule (€23.000) vilken var i träning hos Westholm mellan två och femårssäsongen och bland annat vann ett Klass II-lopp i hans regi.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">721 hästar och sex betäckningsrätter – så ser internetaktören Traveras katalog ut för kvällens auktion. Bland de 15 travarna i kategorin starthästar är sjuårige valacken <strong>Cuenca</strong> (e. Up And Quick) med meriterad med 421.200 kronor på kontot.</p>



<p>Förutom starthästarna finns fyra tvååringar – efter Flocki d’Aurcy, Cash Gamble, Muscle Massive och Pascia’ Lest – och två fölston ute för försäljning. </p>



<p>En livstids betäckningsrätt vardera i Raja Mirchi och Trixton är ute till försäljning, liksom betäckning 2023 i Brillantissimel, Face Time Bourbon, Southwind Frank och Önas Prince.</p>



<p><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här går det att se alla hästar som bjuds ut och följa budgivningen under kvällen.</a></p>

Fokustema
Morgonsvepet
Läs senare
”Han ska klara uppgiften”
Kolgjini först ut att hylla Steinlager, Frode Hamre om storfavoriten som årsdebuterar, svensk uppfödningsvinnare radar segrar i Italien, finsk drottning tillbaka efter åtta månader och nytt proffs i Gävle.
Här är lördagens ”Sju nyheter vid sju”.
Här är lördagens ”Sju nyheter vid sju”.
