
<p class="has-drop-cap wp-block-paragraph">1Man gör bäst i att ta på sig haklapp innan man vilar ögonen på eftermiddagens startfält på Vinovo-banan i Turin (första start kl. 14.40).</p>



<p class="wp-block-paragraph">Alessandro Gocciadoro låter flertalet av sina storstjärnor göra årsdebut vid eftermiddagens tävlingar och bland dem utmärker sig framförallt<strong> Expo Wise As</strong> (e. Ready Cash).</p>



<p class="wp-block-paragraph">Fjolårets vinnare av långa E3-finalen, Derby del Trotto samt Gran Premio Orsi Mangelli kommer till start i fyraåringsloppet Premio Une de Mai (€12.100) och kommer mer eller mindre till dukat bord.</p>



<p class="wp-block-paragraph">Samma sak kan inte sägas om fjolårets Sweden Cup-vinnaren tillika Åby Stora Pris-tvåa <strong>Bengurion Jet</strong> (e. Maharajah).<br>Sjuåringen inleder från spår åtta i ett sprinterlopp där även fjolårets Sweden Cup-finalist tillika stallkamraten <strong>Synergy</strong> (e. Father Patrick) inleder sin säsong.</p>



<p class="wp-block-paragraph">Startfältet utgörs även av 1.09,8-travaren <strong>Cosmo Spritz </strong>(e. Igor Font) som närmast kommer från seger i Gran Premio Padovanelle (€37.400), Gocciadoros <strong>Always Ek</strong> (e. Filipp Roc) som deltog i Jämtlands Stora Pris ifjol och vunnit lopp på Vincennes under vintern samt Gennaro Casillos<strong> Akela Pal Ferm</strong> (e. Maharajah) som vann Grupp I-loppet Gran Premio del Comuni (€154.000) i november.</p>



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



<p class="has-drop-cap wp-block-paragraph">2Blott 264 kronor stannade utdelningen för åtta rätt på i föra veckans V86-omgång och det ger saftig dubbeljackpot ikväll med över tio miljoner kronor extra i åttarättspotten. Solvalla (första start 18.15) och Jägersro (start 18.27) delar på expresstravet.</p>



<p class="wp-block-paragraph">Reijo Liljendahl är inne på sin sista säsong som tränare på svensk mark, då han aviserat flytt till andra sidan Atlanten i höst. I vinter har hans hästar fått ägna sig åt träning, men ikväll på Solvalla är det dags för årets första starter. Hela fem av stallets hästar dyker upp på Solvalla och det handlar om högintressanta namn.</p>



<p class="wp-block-paragraph">Bland annat italienska stoet <strong>Eteria</strong> (e. Tactical Landing) var trea i Breeders Course-finalen för ston under Elitloppshelgen och var hård betrodd i långa E3-finalen, där hon dock fick strykas. Efter en femteplats i comebacken i september väntade nytt uppehåll och ikväll testas hon i ett försök i Solvallaserien med fyra segrar på sex starter bakom sig i karriären.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/eteriauo-617x333.jpg" alt="" class="wp-image-457226"/><figcaption class="wp-element-caption">Reijo Liljendahl-tränade Eteria. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">USA-födda <strong>Lavender</strong> (e. Walner) ordnade Liljendahls senaste seger när hon annandag jul vann ett tvååringslopp på Solvalla efter att ha kommit från tävlande i USA tidigare under tvååringssäsongen. Nu ställs det treåriga stoet mot äldre konkurrenter i ett stolopp.</p>



<p class="wp-block-paragraph">I treåringsloppet som bär Sören Nordins unghäststjärna Active Bowlers namn gör Reijos jänkare <strong>Ronno</strong> (e. Walner) årsdebut, efter att ha slutat tvåa-trea i Breeders Crown respektive Svampen i sina enda två starter som tvååring.</p>



<p class="wp-block-paragraph">På Jägersro får Johan Untersteiner bära tungt favoritskap med<strong> Mateo di Quattro</strong> (e. Bird Parker), som radat upp starka insatser i höst och vinter.</p>



<p class="wp-block-paragraph">Sulkysports spelstuga med viktiga punkter, spikar, drag och favoriter i fara i jackpotomgången på V86 publiceras som vanligt klockan 12.00 idag.</p>



<p class="wp-block-paragraph"><em>Vill du spela V86 tillsammans med Sulkysport kan du välja mellan följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/251721_V86_2024-03-27_40_1" class="">Sulkysport Lilla V86 – 15 andelar á 95 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206235_V86_2024-03-27_40_1" class="">Sulkysport Stora V86 – 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">3Gösta Nordin var förste svenske kusk som klev in i tusenklubben när den äldste i brödratrion Gösta-Gunnar-Sören tog seger 1.000 år 1956. Dessutom blev han allsvensk champion, tog tio kuskchampionat på Solvalla och vann totalt 1.638 lopp.<br>Den lysande stjärnan bland de fyrbenta under Göstas karriär var förstås kejsaren Big Noon och både Gösta och Big Noon är invalda i travsportens Hall of Fame.</p>



<p class="wp-block-paragraph">Men Gösta värnade också om de små och 1992 – åtta år efter hans död – kördes Gösta Nordins Minneslopp för amatörkuskar för första gången, då Ove Hultman segrade med <strong>Speed Crack</strong> (e. Crack Shot). Bland vinnarna genom åren finns också namn som Björn Goop (som 18-åring 1994) och Solvallas nuvarande måldomare Björn Wikander.<br>Ett vandringspris ligger i potten och ska erövras tre gånger av samma körsven för att bli ständig egendom. Dit har ingen nått ännu. Lars Adler och Björn Sjöström vann två gånger vardera 1997-2000, men ikväll kan vandringspriset stanna hos en kusk för gott.</p>



<p class="wp-block-paragraph">Rommeamatören Andreas Peterson har vunnit loppet de två senaste åren, en gång vardera med Emma-Sara Sjöbergs brödraduo<strong> Dark Roadster</strong> (e. Super Photo Kosmos) respektive <strong>Red Hot Roadster</strong> (e. Red Hot Dynamite). Ikväll finns han i startlistan igen och sitter bakom ett starkt kort i Sybille Tinters danske femåring <strong>Hot Dansk Dynamite </strong>(e. Partout Simoni), som visat fin vinterform och vunnit två av de tre senaste starterna med tränaren i vagnen.<br>Av motståndarna vet även Lukas Svedin, Sune L Nilsson och Mats Holmstedt hur det känns att vinna Gösta Nordins Minneslopp.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/rogernordin-350x225.jpg" alt="" class="wp-image-455524"/><figcaption class="wp-element-caption">Roger Nordin. Foto: stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Men den kanske mest spännande kusken i startlistan bär namnet Nordin. Det handlar om 41-årige Roger som är barnbarn till Gösta Nordin! Rogers pappa Rolf var proffstränare på Solvalla, men själv tog 41-årige Roger körlicens först förra året.<br>– <em>Pappa ville hålla mig så långt borta från travet som möjligt</em>, har Roger berättat i en <a href="https://sulkysport.se/nordin-tillbaka-pa-solvalla/" target="_blank" rel="noreferrer noopener">intervju med Sulkysport</a>.</p>



<p class="wp-block-paragraph">Förra året körde han två lopp och nu är det alltså dags för livets tredje start är han kör Zandra Vidén-tränade <strong>Seaside Heights</strong> (e. Uncle Lasse), som han även körde till tredjeplatsen i sitt livs första lopp förra sommaren.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/03/27v86.pdf" class="">Här kan du ta del av dagens startlistor till tävlingarna på Jägersro och Solvalla.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4Dagens högst doterade travlopp på europeisk mark avgörs i Marseille (första start kl. 13.55).</p>



<p class="wp-block-paragraph">Det handlar om den andra etappen av Grand National du Trot (€90.000) och ser tre sexåriga hästar som huvudrollsinnehavare i jakten på de 40.500 euro som vinnaren belönas med.</p>



<p class="wp-block-paragraph">Romain Derieux luftar <strong>Ies We Kan</strong> (e. Carat Williams), Pascal Lelievre bidrar med <strong>Illusion Jipad</strong> (e. Boccador du Simm) och den forne Gelati Cut-tränaren Romain Christian Larue startar<strong> Ibiscus Man</strong> (e. Booster Winner).</p>



<p class="wp-block-paragraph">I sadelloppet Prix de Caves de Saint-Marc de Caromb (€30.000) drabbar blott åtta hästar samman och bland dem finns två svenskfödda hästar.</p>



<p class="wp-block-paragraph">David Cinier tränar såväl <strong>Digital Indy </strong>(e. Super Photo Kosmos) som <strong>Deep Pockets</strong> (e. Ready Cash) i detta lopp med 3.000 meter som grunddistans och där vinnaren tar hem 13.500 euro.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/marseille-borely-2024-03-27/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingar i Marseille.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5Det franska travförbundets ordförande Jean-Pierre Barjon har nu hästar utsprida hos fyra olika tränare på svensk mark efter att välstammade <strong>Fern Kronos</strong> (e. Father Patrick) 1.14,0ak/84.338 kr sänts till Daniel Wäjersten.</p>



<p class="wp-block-paragraph">Det treåriga stoet har gjort fem starter på italiensk mark i regi Andrea Guzzinati och räknat hem två segrar, men finns sedan kort tid tillbaka hos Bergsåkerstränaren.</p>



<p class="wp-block-paragraph">Fern Kronos mor <strong>Unison Kronos </strong>(e. Donato Hanover) 1.10,4ak/1.234.092 kr är helsyster till den tolvfaldiga miljonärskan<strong> Lisa America </strong>(e. Varenne), slutade trea i såväl Oaks del Trotto som Fyraåringseliten för ston och var därtill femma i finalen av Stosprintern år 2017 efter att vunnit sitt uttagningslopp.</p>



<p class="wp-block-paragraph">Fern Kronos är svenskfödd och anmäld till merparten av alla insatslopp på svensk mark.</p>



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



<p class="has-drop-cap wp-block-paragraph">6Det kryllar av fina startfält på svenska banor under påsken, men annandag påsk-klassikern Yngve Larssons Memorial i Halmstad får tyvärr sägas ha blivit en riktig besvikelse.</p>



<p class="wp-block-paragraph">Blott sju hästar kamperar om segerchecken på 100.000 kronor och bland dem är det den tioårige hedershästen <strong>Heart of Steel </strong>(e. Cantab Hall) som är mest poängstark med 1.865 startpoäng.</p>



<p class="wp-block-paragraph"><strong>Startlista Yngve Larssons Memorial</strong><br><em>1.640 meter autostart</em></p>



<ol class="wp-block-list">
<li>Dragster – Ola Samuelsson</li>



<li>Sahara Peyote – Stefan Persson</li>



<li>Charliebrown Effe – Carl Johan Jepson</li>



<li>Night Brodde – Conrad Lugauer</li>



<li>Osterc – Torbjörn Simberg</li>



<li>Heart of Steel – Peter Untersteiner</li>



<li>Aquarius Face – Adrian Kolgjini</li>
</ol>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/img2083-617x397.jpg" alt="" class="wp-image-471551"/><figcaption class="wp-element-caption">Heart of Steel. Foto: Kjeld Mikkelsen/KM Foto</figcaption></figure>



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



<p class="has-drop-cap wp-block-paragraph">7Spelbolaget ATG arrangerar traditionsenligt V75-spel fyra dagar i följd under påsken med start under skärtorsdagen.<br>Sulkysport erbjuder tips till samtliga V75-dagar med tipspublicering enligt nedanstående schema:</p>



<ul class="wp-block-list">
<li>28 mars – <strong>Gävle</strong> – tipset publiceras 28 mars kl. 12.00</li>



<li>29 mars – <strong>Färjestad</strong> – tipset publiceras 28 mars kl. 20.00</li>



<li>30 mars – <strong>Klosterskogen</strong> – tipset publiceras 29 mars kl. 20.00</li>



<li>31 mars – <strong>Romme</strong> – tipset publiceras 29 mars kl. 12.00</li>
</ul>

Fokustema
Morgonsvepet
Läs senare
Europatoppar gör entré
Om eftermiddagens namnstarka årsdebutanter i italienska Turin, men även desto mer okända storloppsdeltagare i Marseilles största lopp för året liksom matnyttigheter inför kvällens tävlingar på svensk mark kan du bland annat läsa i dagens morgonsvep.
