
<p class="has-drop-cap wp-block-paragraph">1 Det delas ut 9.737.000 kronor (icke prisplacerades &#8221;stödpeng&#8221; exkluderat) när Åby skapat sin superdag denna majlördag. Paralympiatravet med 1,5 miljoner till vinnaren, en miljon vardera i både Konung Gustav V:s och Drottning Silvias Pokal, samt en kvarts miljon till de som tar hem femåringsloppen Lyon Grand Prix och Lovely Godivas Minne. Lägsta förstapriset är 100.000 kronor i ett treåringslopp. Snacka om travfest!</p>



<p class="wp-block-paragraph">I huvudlöpningen är favorittrycket stort på Björn Goops <strong>San Moteur</strong> (e. Panne de Moteur), som vunnit 16 av 21 starter i livet och siktas mot Elitloppet som nästa uppgift efter denna. Förra sommaren segrade San Moteur på världsrekordet 1.09,7a/2.140 meter i Jubileumspokalen.</p>



<h2 class="wp-block-heading">Här är de tio snabbaste vinnarna av Olympiatravet/Paralympiatravet genom tiderna:</h2>



<p class="wp-block-paragraph"><em>År, vinnare (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2018 <strong>Ringostarr Treb </strong>(e. Classic Photo) – Wim Paal (Jerry Riordan) – 1.10,0a</li>



<li>2015 <strong>B.B.S.Sugarlight</strong> (e. Super Light) – Peter Untersteiner (Fredrik Solberg) – 1.10,7a</li>



<li>2014 <strong>Solvato</strong> (e. Donato Hanover) – Veijo Heiskanen – 1.10,9a</li>



<li>2016 <strong>Your Highness </strong>(e. Chocolatier) – Björn Goop (Fabrice Souloy) – 1.10,9a</li>



<li>2017 <strong>Lionel</strong> (e. Look de Star) – Göran Antonsen (Daniel Redén) – 1.10,9a</li>



<li>2021 <strong>Delia du Pommereux </strong>(e. Niky) – Erik Raffin (Sylvain Roger) – 1.10,9a</li>



<li>2013 <strong>Maharajah</strong> (e. Viking Kronos) – Örjan Kihlström (Stefan Hultman) – 1.11,0a</li>



<li>2019<strong> Handsome Brad</strong> (e. Brad de Veluwe) – Carl Johan Jepson (Ulf Stenströmer) – 1.11,0a</li>



<li>2009<strong> Triton Sund</strong> (e. Viking Kronos) – Örjan Kihlström (Stefan Hultman) – 1.11,1a</li>



<li>2011 <strong>Brioni</strong> (e. Timberland) – Joakim Lövgren – 1.11,4a</li>
</ul>



<p class="wp-block-paragraph">Sulkysport har grävt i historien och tittat i nutid när det gäller dagens tre största löpningar.<br>Klicka på länkarna för att se ”det snackas om…”:</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/det-snackas-om-paralympiatravet-3/" target="_blank" rel="noreferrer noopener">Paralympiatravet: ”För många det största ögonblicket i loppets historia”</a></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/det-snackas-om-drottningpokalen-3/" target="_blank" rel="noreferrer noopener">Drottning Silvias Pokal: ”Ende tränaren som vunnit förut och Kihlström står vid sidan”</a></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/det-snackas-om-kungapokalen-3/" target="_blank" rel="noreferrer noopener">Konung Gustaf V:s Pokal: ”Hederspriset som aldrig kommer att delas ut”</a></p>



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



<p class="has-drop-cap wp-block-paragraph">2 Åbytravet lyfter fram en annan av banans stora stjärnor genom tiderna, superstoet<strong> Lovely Godiva</strong> (e. Ideal du Gazeau), 1.12,2ak/12.549.624 kronor! Tillsammans med Per-Olof Pettersson firade järnladyn stora framgångar, eller vad sägs om Breeders Crown både som tre- och fyraåring, Guldstoet, Stochampionatet och S:t Leger som unghäst. Som äldre smäller segern i Prix de France och framför allt andraplatsen i Prix d’Amérique bakom Moni Maker 1999 högst. Pd’A-silver tog hon som nioåring. Den säsongen blev också Lovely Godivas främsta med drygt 2,8 miljoner kronor insprunget, halvmiljonen bättre än när hon var fyra år.<br>Lördagens många storlopp på Åby då? Ja, Lovely Godiva vann försök till Drottningpokalen, men fick nöja sig med fjärdeplatsen i finalen där Serena och Christer Nylander vann. I Olympiatravet deltog hon två gånger: oplacerad 1997 och trea två år senare efter succévintern i Paris.<br>Totalt vann Per-Olof Pettersson och Lovely Godiva 46 lopp tillsammans!<br>Sveriges förste miljonär Lyon hyllas med Lyon Grand Prix.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-6-maj/(öppnas i en ny flik)" target="_blank" rel="noreferrer noopener">Här kan du ta del av Sulkysports V75-tips till tävlingarna på Åby och finner även länkar som för dig vidare till våra olika andelsspel.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3 Alla blickar mot Åby (första start 14.35), men det tävlas både på förmiddagen och kvällen på annat håll i vårt avlånga land. Under kvällsakten i Gävle (start 18.30) står biljetter till Solvallas Elitloppshelg på spel – i speedrace. Både ett varmblod och ett kallblod får chansen att kvala in till loppen på Solvalla över 640 meter med autostart, men uttagningsloppen ikväll körs över 500 meter längre distans, 1.140 meter med bilstart.<br>Varmblodens speedrace på Solvalla namnges loppets store dominant <strong>M.T.Insider </strong>(e. Offshore Dream), som vann loppet fyra av de fem senaste åren och lade tävlingsskorna på hyllan efter fjolårets triumf.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/08/jaguardreamcsd220813adamstromstalltz-617x470.jpg" alt="" class="wp-image-340550"/><figcaption class="wp-element-caption">Jaguar Dream gör årsdebut i Gävle. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Flera intressanta namn dyker upp i kvällens supersprint, däribland Claes Sjöströms årsdebutant <strong>Jaguar Dream</strong> (e. Love You), som vann på 1.09,3a/1.640 meter förra sommaren, och fartfyllde<strong> Dark Roadster </strong>(e. Super Photo Kosmos).<br>I kallblodens supersprint märks femfaldige miljonären <strong>Smedheim Solan </strong>(e. Bork Odin) och fjolårsvinnaren i speedrace på Solvalla, <strong>Smedsbo Faksen </strong>(e. Järvsöfaks) som kördes till vinst av Åke Svanstedt.<br>Lördagen inleds med breddlopp på Jägersro (start 11.10) och Solänget (start 12.00).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/05/230506.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">4 På Vincennes (13.24) avgörs det idag tre Grupp-lopp varav ett ser svenskt deltagande.<br>I Prix Roger Ledoyen (€90.000) för sadelhästar som tjänat upp till 750.000 euro prövar Tomas Malmqvist lyckan med<strong> Estelle Nordique</strong> (e. Real de Lou) som inleder från startvolten över 2.850 meter voltstart tillsammans med Adrien Lamy.</p>



<p class="wp-block-paragraph">Nioåringen tillmäts inga större möjligheter av fransk press, men det gör däremot svenskfödde<strong> Oracle Tile </strong>(e. Ready Cash) som startar i Quinté-loppet Prix de Rouergue (€75.000).<br>Thierry Duvaldestins sjuårige hingst körs som vanligt av Clément Duvaldestin i detta lopp över 2.100 meter autostart som även innehåller Erik Bondos svenskfödde Joke Face-son <strong>Kennedy</strong>.</p>



<p class="wp-block-paragraph">Tomas Malmqvists andra bidrag under dagens tävlingar på Vincennes är <strong>Howdy Partner</strong> (e. Repeat Love) som kommer till start i Prix de Combree (€68.000).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-05-06/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/prixlorraine4-617x479.jpg" alt="" class="wp-image-431025"/><figcaption class="wp-element-caption">Oracle Tile jagar sin femte seger på fransk mark. Foto: Gerard Forni.</figcaption></figure>



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



<p class="has-drop-cap wp-block-paragraph">5 Vermobanan i Helsingfors värmer idag upp inför morgondagens Finlandia Ajo med storloppet Arvid Åvall Stoderby (€57.600) för femåriga, inhemska ston.<br>I förra veckan var det uttagningslopp från vilka <strong>Speedy Norwegian</strong> (e. Lexus Font) och <strong>Cream Candy</strong> (e. The Bosses Lindy) gick segrande och det är också den duon som har de innersta startspåren i dagens final.</p>



<p class="wp-block-paragraph"><strong>Startlista Arvid Åvall Stoderby (€57.600)</strong><br><em>2.120 meter autostart, förstapris: 24.000 euro</em></p>



<ol class="wp-block-list">
<li>Speedy Norwegian (e. Lexus Font) – Kenneth Danielsen</li>



<li>Cream Candy (e. The Bosses Lindy) – Emma Väre</li>



<li>Over My Shoulder (e. Maharajah) –<strong> </strong>Santtu Raitala</li>



<li>Alma Cotter (e. Maharajah) – Jarmo Saarela</li>



<li>Magic Madonna (e. Maharajah) – Pekka Korpi</li>



<li>Like di Serafino (e. Like di Poggio) – Ari Moilanen</li>



<li>My Way Luxi (e. Pilgrims Taj) – Tuukka Varis</li>



<li>Busy Combo (e. Classico Merrett) – Jukka Torvinen</li>



<li>Blue Ocean (e. S.J.&#8217;s Caviar) – Hannu Torvinen</li>



<li>Anna K.Garden (e. Crazed) – Olli Koivunen</li>



<li>Lake&#8217;s Diana (e. Bird Parker) – Tapio Perttunen</li>



<li>Zara Avenger (e. Ready Cash) – Juha Utala</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">6Välkommen till en världsstjärna. Så inleds dagens ledare i banprogrammet till tävlingarna på den danska &#8221;pyttebanan&#8221; Bornholm (första start 11.00) vars bankropp blott mäter 580 meter och marknadsförs som världens minsta travbana.</p>



<p class="wp-block-paragraph">Där går nämligen karriären vidare för 14-årige<strong> Slide so Easy </strong>(e. Quite Easy U.S.) 1.10,1ak/5.514.269 ddk efter fyra säsonger hos Kenneth Nielsen och sju säsonger hos Flemming Jensen.</p>



<p class="wp-block-paragraph">Karriärens största merit hämtas från år 2019 då hästen slutade tvåa i International Trot på Yonkers bakom <strong>Zacon Gio</strong> och i det loppet deltog han även ifjol som 13-åring, men då fick han inte med sig några prispengar.<br>Genom fjolårssäsongen gick han segerlös på tio starter, men noterades faktiskt för sitt absoluta rekord då han sprang 1.10,1a/1.600 meter som trea i Rex the Greats lopp på Charlottenlund under derbydagen i augusti.<br>Nu är det hemmaamatören Mads Pedersen som tagit över träningen av valacken.</p>



<p class="wp-block-paragraph"><strong>Startlista Hotel Herolds Ärespremie</strong><br><em>2.160 meter autostart, förstapris: 5.000 danska kronor</em></p>



<ol class="wp-block-list">
<li>Slide so Easy – Mads Pedersen</li>



<li>Fortune Boko – Kim Hjort</li>



<li>Apollo Damgård – Niels Kristian Hansen</li>



<li>Capture – Frank Mikkelsen</li>



<li>Diamondwind – Jonas Mikkelsen</li>



<li>Asger Molar – Laura Pedersen</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">7 Travera-auktioner rullar som vanligt på lördag in och lördag ut. Ikväll finns 14 objekt till salu bland vilka STL-meriterade <strong>Global Believer</strong> (e. Donato Hanover) 1.11,3ak/499.150 kr får anses sticka ut mest.<br>Under fjolåret var sjuåringen tvåa i två Klass I-försök på Axevalla och han har karriären igenom tränats av Halmstadproffset Håkan K Persson.</p>



<p class="wp-block-paragraph">En häst som visat färsk form som finns bland de starthästar som är till salu är<strong> Irma Sisu (</strong>e. Trixton) 1.12,7ak/336.540 kr.<br>I onsdags slutade stoet tvåa i ett V86-lopp på Bergsåker på nya voltrekordet 1.14,7/2.140 meter.</p>



<p class="wp-block-paragraph"><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här kan du ta del av kvällens utbud på Travera.</a></p>

Fokustema
Morgonsvepet
Läs senare
I potten: 9.737.000 kronor
På dagens stortävlingar på Åby fokuserar vi givetvis främst i dagens morgonsvep, men vi gör även avstamp till Frankrike och Finland där det likaså tävlas om stora prischeckar.
