
<p class="has-drop-cap wp-block-paragraph">1 Sedan året då <strong>Ina Scot</strong> (e. Allen Hanover) slog hingstarna i Svenskt Travderby och Europaderbyt 1993 – som höjdpunkten under en rent fenomenal fyraåringssäsong – har superstoets hemmabana Mantorp hyllat hästen. I år sker hyllningen i Eskilstuna, då <strong>Sundbyholm</strong> (första start 14.45) fick ta över Mantorps V75-omgång i samband med EHV-1-smittan på östgötabanan.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/09/inascotdef-617x333.jpg" alt="" class="wp-image-109509"/><figcaption class="wp-element-caption">Ina Scot, Helen A Johansson och Kjell P Dahlström. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Ina Scot lämnade jordelivet 2013, men hennes minne lever kvar efter den sagolika karriären som gav seger i Prix d’Amérique, rader av klassiska unghästlopp och världsrekord som äldre i Oslo Grand Prix. Bland Mycket annat för sin tränare Kjell P Dahlström och – ju längre karriären led – körsven Helen A Johansson.<br>Totalt blev det 90 starter (54–11–6) och 20.252.530 kronor insprunget för stoet som tävlade under sex säsonger 1991–1996.</p>



<p class="wp-block-paragraph">Ina Scots Ära har sett många starka vinnare genom åren och för två år sedan krossade Per Nordströms Elitloppshäst <strong>Önas Prince</strong> (e. Chocolatier) löpningsrekordet med en sekund när han segrade på 1.11,1a/2.140 meter.<br>Årets upplaga är internationell med svenske <strong>Barack Face</strong> (e. Ready Cash), italienske <strong>Dakovo Mail</strong> (e. Nad Al Sheba) och amerikanske <strong>Periculum</strong> (e. Muscle Hill) i huvudrollerna på förhand.</p>



<p class="wp-block-paragraph"><strong>Snabbaste vinnarna av Ina Scots Ära:</strong><br><em>År, vinnare (far) – Körsven (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2021 <strong>Önas Prince</strong> (e. Chocolatier) – Per Nordström – 1.11,1a</li>



<li>2011 <strong>Deuxieme Picsous</strong> (e. In Love With You) – Johnny Takter (Johan Lejon) – 1.12,1a</li>



<li>2016 <strong>Southwind Mozart</strong> (e. Muscle Hill) – Jörgen Sjunnesson (Veijo Heiskanen( – 1.12,1a</li>



<li>2020 <strong>Ecurie D. </strong>(e. Infinitif) – Björn Goop (Frode Hamre) – 1.12,2a</li>



<li>2017 <strong>Muscle Hustle</strong> (e. Muscle Mass) – Robert Bergh – 1.12,3a</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">2 Eskilstunas tävlingar i eftermiddag spetsas med rejäl jackpot på V75. 27.479.568 kronor extra ligger i sjurättspotten från lördagstävlingarna på Solvalla.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/07/greatskillsdwm220725adamstromstalltz-617x396.jpeg" alt="" class="wp-image-331941"/><figcaption class="wp-element-caption">Stochampionatsvinnaren Great Skills möter Lara Boko. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Ina Scots Ära till trots, den mest spännande hästen dyker upp i silverdivisionen. Veckans silverlopp är öppet för alla ston oavsett prissumma och fyra tränare tar chansen att möta hingstar och valacker med betydligt mindre på bankboken. </p>



<p class="wp-block-paragraph">En av dem är Timo Nurmos som låter 2018-kullens drottning <strong>Lara Boko</strong> (e. Djali Boko) årsdebutera efter unghästsäsonger som innehållit segrar i Svenskt Trav-Oaks som treåring och Derbystoet och Breeders Crown som fyraåring. Tolv segrar på 21 starter och 9.785.314 kronor insprunget har det blivit så här långt.</p>



<p class="wp-block-paragraph">– Laras träning har gått bra, nästan som planerat, men influensa sköt upp årsdebuten något. Jag hade tänkt årsdebutera i stoeliten under Elitloppshelgen, men tänkte att det blir tufft att årsdebutera över kort distans. Vi tar en start i taget, säger Timo Nurmos till finska Hevosurheilu.<br><br>Värsta motståndaren är troligen en kullkamrat: Stochampiontsvinnaren <strong>Great Skills</strong> (e. Ready Cash). Hon har årsdebuten avklarad, men hade en tuff uppgift med dubbla tillägg i ett diamantstoförsök.</p>



<p class="wp-block-paragraph">Sulkysports tipsexpert räknar med att Lara Boko är segermogen direkt och enkelstreckar: <em>”Hon utsågs till Årets sto i svensk travsport under fjolåret och även om hon stöter på sin banekvinna från Stochampionatet Great Skills så tror vi att hon inleder året med seger.”</em></p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://sulkysport.se/spelstugan/v75-tips-eskilstuna-3-juni/" target="_blank">Här är Sulkysports stora tipsgenomgång inför V75.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2023-06-03_14_5">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2023-06-03_14_5">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206689_V75_2023-06-03_14_5">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3  ST:s sommarturné gör sitt andra stopp idag. Sommartravet går under rubriken ”Travets största satsning någonsin” och inleddes med V86-tävlingarna i Lindesberg i onsdags. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/skarmavbild20230602kl.09.25.19-617x286.jpg" alt="" class="wp-image-452988"/><figcaption class="wp-element-caption">Det ekade tomt på publikplats på Fornaboda i onsdags.</figcaption></figure>



<p class="wp-block-paragraph">1.463 personer tog sig till Fornaboda och det var tusen personer färre än förra året när Bergslagsloppet hölls i Lindesberg inför 2.463 besökare i början av juli.</p>



<p class="wp-block-paragraph">Eskilstuna har att matcha Mantorptravets 1.905 personer från ifjol – för den som är intresserad av publiksiffror?</p>



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



<p class="has-drop-cap wp-block-paragraph">4 Tomas Malmqvist startar i princip någon häst varje dag i Frankrike och lördagen är inte undantagen. Idag är det <strong>Pontchateau</strong> (första start 11.30) som är destination för treårige <strong>Kobayashi</strong> (e. Face Time Bourbon) som startar i Prix E.C.R. (€22.000) tillsammans med Antoine Wiels.</p>



<p class="wp-block-paragraph">En seger har det blivit fem starter in i karriären och idag är förutsättningarna 2.800 meter voltstart när han jagar sin andra fullträff och 9.900 euro.</p>



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



<p class="has-drop-cap wp-block-paragraph">5 Åren 2009-2015 syntes Malin Löfgren flitigt, hon bytte Östersund mot Solvalla och firade stora triumfer som tränaren bakom Rixhästen <strong>Sanity</strong> (e. Love You), 1.09,2ak/10.280.145 kr. 82 starter (31-15-8) och dubbla starter i Elitloppet blev det för sagohästen.<br>Bland segrarna i Sverige finns Norrbottens Stora Pris, Silverhästen och V75:s Jubileumslopp. I Frankrike gjorde han tio starter och vann fyra lopp. De penningmässigt största segrarna kom i Prix de l&#8217;Union Européenne och Prix de Brest på Vincennes, men den mest minnesvärda triumfen är nog den i Grand Prix Federation Regionale du Nord i Le Croisé-Laroche 2013, då han besegrade självaste Ready Cash.</p>



<p class="wp-block-paragraph">Numera driver Malin Löfgren ett mindre stall utanför Oviken, men i fyraåriga stoet <strong>Miracolosa</strong> (e. From Above) har hon en spännande travare. En seger och två andraplatser har Miracolosa inlett karriären med och ikväll dyker hon upp på <strong>Dannero</strong> (första start 18.30).</p>



<p class="wp-block-paragraph">Lördagen i Trav-Sverige inleds annars med bubbla breddloppstävlingar, i <strong>Rättvik</strong> (start 11.00) och på <strong>Åby</strong> (start 11.10).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/05/230603.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">6 Tvååringstävlandet i USA drog igång förra veckan och idag är det dags för baby race på Meadowlands och då tittar de första avkommorna till Marcus Melanders unghäststjärna <strong>Greenshoe</strong> ut.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2019/06/greenshoe3152019lisa-617x374.jpg" alt="" class="wp-image-45322"/><figcaption class="wp-element-caption">Greenshoe har sina första tvååringar till kval idag. Foto: Lisa Photo</figcaption></figure>



<p class="wp-block-paragraph">Marcus Melander kvalar sex Greenshoe-tvååringar. <strong>Call of the Wild</strong> (u. To Dream On), <strong>Cardinal Hanover</strong> (u. Cedar Dove), <strong>Landaluci</strong> (u. High Sobriety), <strong>Lysithea</strong> (u. Hillambro), <strong>P.J.’s Dream</strong> (u. Dream Baby Dream) och <strong>Sir Fred Jones</strong> (u. Stella Jane) är hans bidrag, medan Lucas Wallin plockar ut duon <strong>Good Faith Hanover</strong> (u. Gatka Hanover) och <strong>Supernova Hanover</strong> (u. Starita).</p>



<h2 class="wp-block-heading">Namn – Auktionspris</h2>



<ul class="wp-block-list">
<li><strong>Supernova Hanover</strong> – $265.000</li>



<li><strong>Lysithea</strong> – $200.000</li>



<li><strong>Cardinal Hanover</strong> – $165.000</li>



<li><strong>Good Faith Hanover</strong> – $150.000</li>



<li><strong>Landaluci </strong>– $105.000</li>



<li><strong>Call of the Wild </strong>– $100.000</li>



<li><strong>P.J.’s Dream</strong> – $100.000</li>



<li><strong>Sir Fred Jones</strong> – $85.000</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">7 Igår hölls den uppskjutna Elitauktionen och idag gör Travera comeback efter en veckas uppehåll. Där bjuds det ut 19 travare – allt från ettåringar till fölston och en livstids betäckningsrätt i <strong>Hail Mary</strong>.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/03/sunrisedkm220316adamstromstalltz-617x369.jpg" alt="" class="wp-image-278148"/><figcaption class="wp-element-caption">Sunrise och Dante Kolgjini plockar ner Dareios di Poggio från dödens vid en tidigare seger. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Vid Sulkysports publicering av ”sju nyheter vid sju” låg högsta budet – 250.000 kronor – på den toppstammade fyraåringen <strong>Sunrise </strong>(e. Walner-Morning Glow), 1.10,5a/426.042 kr. Den USA-födde valacken har startat 15 gånger och vunnit tre lopp i regi Adrian Kolgjini och är sprungen ur Peridots fantastiska möderne.</p>
