
<p class="has-drop-cap">1Paralympiatravet. Konung Gustaf V:s Pokal. Drottning Silvias Pokal. <strong>Åbytravet</strong> (första start 14.35) dukar upp till årets första riktiga storloppsdag i Sverige med tre miljonlopp som höjdare. Sammanlagt delas det ut 9,5 miljoner kronor i prispengar idag!</p>



<p>Sulkysport har gått igenom de stora finalerna och plockat fram godbitarna bland hästar, kuskar, tränare, avelshingstar, auktionspriser och tittat tillbaka i historiken.</p>



<ul class="wp-block-list">
<li><strong>Paralympiatravet: </strong>Från Ingemar Stenmark till <strong>Borups Victory</strong>, <strong>Önas Prince</strong> eller <strong>San Moteur</strong>? Så växte storloppet fram. Dags för en fjärde amatörvinnare? ”Alla” minns <strong>Sugarcane Hanover</strong>. De har gått vidare och vunnit Elitloppet.<br><a href="https://sulkysport.se/paralympiatravet/" target="_blank" rel="noreferrer noopener">Läs mer om Paralympiatravet här!</a></li>



<li><strong>Konung Gustaf V:s Pokal:</strong> Kan Daniel Wäjerstens trio stå emot Alessandro Gocciadoros <strong>Free Time Jepson </strong>eller kan någon annan blanda sig i leken i årets upplaga av Konung Gustaf V:s Pokal? <br><a href="https://sulkysport.se/713196-2/" target="_blank" rel="noreferrer noopener">Läs mer om Kungapokalen här!</a></li>



<li><strong>Drottning Silvias Pokal: S.G.Empress</strong> tar Walmann i ensam tränarledning. Historien talar emot <strong>Vivillion</strong> – eller? Fyra tränare vet hur man vinner. Rekordköpet på auktion i ny final. Kända fadershingstar och en uppstickare. Amatörerna som vunnit förut. <br><a href="https://sulkysport.se/drottningpokalen-walmann-ensam-i-topp/" target="_blank" rel="noreferrer noopener">Läs mer om Drottning Silvias Pokal här!</a></li>
</ul>



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



<p class="has-drop-cap">2Från sportsliga höjdpunkter till totomässiga sådana. Åbys stordag kryddas med saftig jackpot på V75, där nästan 19 miljoner kronor extra ligger i sjurättspotten.<br><em>”Spikarna i omgången hittar vi i Free Time Jepson i Kungapokalen (V75-3) samt Borups Victory i Paralympiatravet (V75-7), som körs av Alessandro Gocciadoro respektive Daniel Wäjersten,”</em> skriver Sulkysports tipsexpert.</p>



<p><a href="https://sulkysport.se/spelstugan/v75-tips-12/">––> Här är Sulkysports stora tipsgenomgång till dagens jackpot.</a></p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2025/04/freetimejepsonagadam.jpg" alt="" class="wp-image-713028"/><figcaption class="wp-element-caption">Free Time Jepson och Alessandro Gocciadoro. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p>När det gäller Alessandro Gocciadoros mycket imponerande vinnare i försöket till Kungapokalen <strong>Free Time Jepson</strong> (e. Face Time Bourbon), så säger italienaren så här på sin bloggsida:<br>– Free Time Jepson har tränat på normalt bara för att underhålla formen och det finns inget negativt att säga. Hästen var inte trött på den tidsnotering han gick i försöket och jag är mycket optimistisk inför finalen. Startspåret är perfekt då jag inte ville ha spår ett eller två och börja långt in bakom bilen. Det blir inga ändringar, säger Alessandro Gocciadoro.</p>



<p>Hos vår samarbetspartner Travnet finns andelar till dagens V75-omgång på Högkvarteret.<br><a href="https://www.atg.se/hogkvarteret/V75_2025-05-03_6_5" target="_blank" rel="noreferrer noopener">Här är alla andelar!</a></p>



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



<p class="has-drop-cap">3Åby lyfter fram två av banans forna stjärnhästar i två femåringslopp där det ena tar plats på V75-kupongen. Det handlar om Lovely Godivas Minne för ston, medan Lyon Grand Prix för hingstar och valacker över lång distans ligger utanför det stora streckspelet. Båda loppen bjuder en kvarts miljon kronor till vinnaren.</p>



<p>Superstoet <strong>Lovely Godiva</strong> (e. Ideal du Gazeau), 1.12,2ak/12.549.624 kr, firade stora tillsammans med Per-Olof Pettersson. 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 framför allt segern i Prix de France och andraplatsen i Prix d’Amérique bakom Moni Maker 1999 högst. Pd’A-silver tog hon som nioåring.<br>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. Totalt vann Per-Olof Pettersson och Lovely Godiva 46 lopp tillsammans!</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/3daimbrodda-617x333.jpg" alt="" class="wp-image-655173"/><figcaption class="wp-element-caption">Daim Brodda och Eirik Höitomt. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Sina sista år tillbringade Lovely Godiva på Brodda Stuteri – uppfödare till Daim Brodda – och hon är begravd på Brodda tillsammans med bland andra <strong>Debbie Brodda</strong> och <strong>Gloria Brodda</strong>. </p>



<p>Årets upplaga av loppet håller mycket hög klass, där sex av tolv deltagare sprungit in över två miljoner med trion <strong>East Asia</strong> (6,1 miljoner), <strong>Daim Brodda</strong> (fem miljoner) och <strong>Ester Degli Dei</strong> (4,8 miljoner) i topp.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/02/lyonmal-617x333.jpg" alt="" class="wp-image-141052"/><figcaption class="wp-element-caption">Lyon och Olle Elfstrand vann Elitloppsförsök 1972. Foto Lars-Erik Lundqvist/Stalltz.se</figcaption></figure>



<p>Sveriges förste miljonär <strong>Lyon</strong> (e. Go), 1.15,1ak*/1.285.785 kr, formade Olle Elfstrand formade till en världsstjärna. 1969, 1970 och 1972 utsågs han till Årets Häst i Sverige och just 1972 blev han förste travare i landet att spränga miljonvallen.</p>



<p>Året efter skrev Lyon in sig i historieböckerna på fler sätt när han inför 16.000 åskådare på Solvalla krossade dubble Prix d’Amérique-vinnaren <strong>Tidalium Pelos</strong> Europarekord över lång distans när Lyon tillsammans med Olle Elfstrand vann med 30-talet meter på 1.17,8/3.180 meter. Totalt vann Lyon 79 av 172 starter och idag hyllas han bland annat av fjolåets norske Derbyvinnare Charron (e. Code Bon).</p>



<p>Efter Åbys stordag blir det kvällstrav i Gävle (första start 18.53). </p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/04/250503.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar.</a></p>



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



<p class="has-drop-cap">4 Fjolårets finska Derbyvinnare – <strong>Lightning Stride</strong> (e. Twister Bi) – startar på Vermo idag och då handlar det om finalen i Arvid Åvallin Tammaderby (€43.000) för femåriga ston.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/09/0m3a3641scaledartikelbild1280-617x412.jpg" alt="" class="wp-image-637003"/><figcaption class="wp-element-caption">Ensam på målfotot i FInskt Derby var Lightning Stride och Santtu Raitala i finska Derbyt förra året. Foto: Terhi Piispa-Helisten</figcaption></figure>



<p>Katja Melkkos stjärna vann sitt försök på 1.14,2a/2.120 meter för Santtu Raitala. Förutom Finskt Derby (€258.000) segrade HPT Nordic AB:s sto i Villinmiehen Tammakilpa (€92.400) förra året.</p>



<p><strong>Arvid Åvallin Tammaderby</strong> (€43.000)<br>Femåriga ston.<br><em>2.120 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Callela Xplosion</strong> (e. Explosive Matter) – Jukka Torvinen</li>



<li><strong>Up Down Lily</strong> (e. S.J.’s Caviar) – Hannu Torvinen</li>



<li><strong>Lightning Stride</strong> (e. Twister Bi) – Santtu Raitala</li>



<li><strong>Christine L Garden</strong> (e. Maharajah) – Tommi Kylliäinen</li>



<li><strong>Callela Ellen </strong>(e. Love You) – Henri Bollström</li>



<li><strong>Sofia Evo </strong>(e. Orlando Vici) – Pekka Korpi</li>



<li><strong>Sands Hybrid</strong> (e. Maharajah) – Ari Moilanen</li>



<li><strong>Lady Marinet</strong> (e. Raja Mirchi) – Jarmo Saarela</li>



<li><strong>Lady Cash </strong>(e. Lexus Font) – Tapio Perttunen</li>



<li><strong>Nothingcomes</strong> (e. Coktail Jet) – Esa Holopainen</li>



<li><strong>Viens Ici</strong> (e. Quite Easy) – Juha Utala</li>



<li><strong>Fornite</strong> (e. Le Monteil) – Olli Koivunen</li>
</ol>



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



<p class="has-drop-cap">5 Nyligen hade Enzo Giordano flyttat från Piemonte till Campania för att komma nära sin ögonsten <strong>Varenne</strong>, vilken fyller 30 år i år. Enzo Giordano dog igår och blev 71 år gammal.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/skarmavbild20250502kl.14.20.29-617x539.jpg" alt="" class="wp-image-714248"/><figcaption class="wp-element-caption">Enzo Giordano och Varenne.</figcaption></figure>



<p>Efter ha sett Varenne i debuten på tv blev han förälskad i hästen och med hjälp av släktingar samlade de ihop 170 miljoner lire – motsvarade 800.000 kronor – vilket krävdes för att genomföra köpet.</p>



<p>Enzo Giordano fick se Varenne vinna tre upplagor av Gran Premio della Lotteria och även stundande Paralympiatravet, som gick under namnet Olympiatravet när Varenne segrade både 2000 och 2002.</p>



<p>Under sina sista dagar av livet – han vårdades under några veckor på sjukhus på grund av en halsinfektion som hindrade honom från att äta – uttryckte han en önskan att Varenne skulle defilera en sista gång på Agnano på söndag i samband med Gran Premio della Lotteria. Idag begravs Enzo Giordano i Chiaia.</p>



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



<p class="has-drop-cap">6 <strong>Vincennes</strong> (första start kl. 13.23) bjuder på flera penningstinna löpningar idag och däribland en semi-classique-löpning – Prix Albert Demarcq (€120.000) – för femåringar över 2.850 meter. <strong>Kanto Avis </strong>(e. Ready Cash) och Benjamin Rochard jagar tredje raka triumfen tillsammans. Närmast kommer duon från vinst i Grupp II-löpningen Prix Robert Auvray (€120.000).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/11/prixcosse4-617x491.jpg" alt="" class="wp-image-524606"/><figcaption class="wp-element-caption">Unico Broline vinst tillsammans med Björn Goop i november 2023 på Vincennes. Foto Gerard Forni</figcaption></figure>



<p>Ur svensk synvinkel står Prix du Rouergue (€75.000) i centrum för sjuåriga och äldre travare. Där startar Sofia Aronsson Hofstedt <strong>Unico Broline</strong> (e. Cantab Hall) och som återvänder till fransk mark efter nästan 1,5 år.</p>



<p>Vid senaste besöket på Vincennes – i november/december 2023 – utmynnade det i seger och en sjundeplats. Vinsten togs i Prix de Cosse le Vivien (€68.000) med Björn Goop i sulkyn.</p>



<p>Idag sköter Clément Duvaldestin tömmarna. Startar i samma lopp gör också svenskfödde <strong>Self Explosive </strong>(e. Explosive Matter) med Matthieu Abrivard i sulkyn.</p>



<p>Mer blågult blir det i Prix de Menton (€56.000) och Franck Nivard tar hand om Christoffer Erikssons <strong>Rossi Garline</strong> (e. Readly Express) i ett lopp över 2.700 meter med 25.200 euro till vinnaren. I samma lopp dyker också svenskfödda duon <strong>Iliade</strong> (e. Varenne) och <strong>Mister Invictus</strong> (e. Ready Cash) upp.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2025-05-03/" target="_blank" rel="noreferrer noopener">Startlistorna till Vincennes tävlingar hittar ni här.</a></p>



<p>Till <strong>Amiens</strong> (första start kl. 18.30) åker Björn Goop-tränade <strong>Kezio Josselyn</strong> (e. Brillantissime) för att starta i Prix Jacques Vagniez (€19.000) och Jérémy Koubiche sitter upp bakom femåringen i ett lopp över 2.400 meter med autostart och där det lockas med ett förstapris på 8.550 euro.</p>



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



<p class="has-drop-cap">7 Någon lyckad start fick inte <strong>Sofie Ericsson</strong> i Dam-EM igår i Alkamaar och ett tredje- och sjundepris kunde hon räkna in med sina två uppsittningar i de tre lopp som avgjordes under den första tävlingskvällen. .</p>



<p>Från rygg ledaren slutade Sofie Ericsson trea med Norman Charisma (e. Armstrong As), men var chanslös att haka på vinnaren och ledaren <strong>Najara Beuckenswijk</strong> (e. Fawkes) och Silje Kristin Eilertsen på 1.19,2a/2.060 meter.</p>



<p>En sjundeplats blev det med Lumiere (e. Conway Hall) efter en resa i tredje inner och utan rygg sista kilometern. Från ledningen vann Eszter Takacs och <strong>Newton Renka</strong> (e. Booster Winner) på 1.17,4a/2.060 meter.</p>



<p>I det första försöket deltog inte Sofia Ericsson och där vann Angelique Scotti och <strong>Nobel BM </strong>(e. Chelsea Boko) på 1.21,0a/2.060 meter efter dödens sista rundan.</p>



<p>Ikväll i Wolvega avslutas EM för damer med två nya lopp.</p>



<h2 class="wp-block-heading">Ställningen inför finaldagen</h2>



<p><strong>Namn – Land – Poäng</strong></p>



<p>1 <strong>Silje Kristin Ellertsen</strong> – Norge – 21<br>– <strong>Eszter Takacs</strong> – Ungern – 21<br>– <strong>Hiltje Tjaisma</strong> – Holland – 21<br>4 <strong>Caroline Gentz</strong> – Tyskland – 20<br>– <strong>Angelique Scotti </strong>– Schweiz – 20<br>6 <strong>Elena Villani </strong>– Italien – 17<br>7 <strong>Sofie Ericsson</strong> – Sverige – 16<br>– <strong>Sara Hautamäki</strong> – Finland – 16<br>9 <strong>Marianne Thorup Nielsen</strong> – Danmark – 15<br>10 <strong>Nadja Reisenbauer</strong> – Österrike – 14<br>– A<strong>ntonia Vaquer Staschel </strong>– Spanien – 14<br>12 <strong>Beatrice Demoulin</strong> – Belgien – 12</p>
