
<p class="has-drop-cap wp-block-paragraph">1 Det blir treåringar i fokus när Solvallas Elitloppshelg inleds vid lunchtid idag med första start 12.45. I ASVT:s auktionslopp tävlar tio hingstar och valacker tävlar om 200.000 kronor i förstapris, medan 15 anmälda ston är uppdelade i två lopp med 100.000 kronor till vinnaren.</p>



<p class="wp-block-paragraph">Åke Lindblom har ett ämne i <strong>Västerbo Exciting </strong>(e. Jocose), som vann Vårfavoriten på Solvalla i april och aldrig varit sämre än trea på fem starter. Hingsten var anmäld till Kriterieauktionen, men ströks och köptes av Lindblom en månad senare.</p>



<p class="wp-block-paragraph">Västerbo Exciting ställs bland annat mot två finalister från Svensk Uppfödningslöpning i höstas, <strong>King Of Twilight</strong> (e. Bold Eagle) och <strong>Pure Steel</strong> (e. Bird Parker), där båda gjorde bort sig med galopp. Både King Of Twilight och Pure Steel var dyringar när de såldes på Elitauktionen: 550.000 respektive 500.000 kronor blev priserna.</p>



<p class="wp-block-paragraph">Ytterligare en Uppfödningsfinalist dyker upp i ett av stoloppen. Jerry Riordan tränar auktionsdyringen – 450.000 kronor – <strong>Pure Harmony</strong> (e. Walner), som gör första starten sedan storloppet på Jägersro i november.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/sa-mycket-kostade-auktionshastarna/" target="_blank" rel="noreferrer noopener">Loppen är öppna för hästar som såldes eller var anmälda till ASVT:s ettåringsauktioner 2021 och så här mycket kostade deltagarna!</a></p>



<p class="wp-block-paragraph">Ikväll är det dags för årets Elitauktion på Infra City i Upplands-Väsby med 100 hästar i katalogen.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/guide-elitauktionen-i-siffror/" target="_blank" rel="noreferrer noopener">Här är en guide om vad som bjuds ut på den selekterade ettåringsauktionen.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">2 Tre dagar i rad blir det kallblodslopp på Solvalla. I eftermiddag inleds det med speedrace, i morgon ett lopp stängt vid 1,5 miljoner och sedan höjdpunkten Elitkampen på söndag. </p>



<p class="wp-block-paragraph">640 meter och bilstart är förutsättningarna som gäller i dagens speedrace, där nio hästar är uppdelade i tre heat, där vinnarna i varje möts i finalen me 100.000 kronor i förstapris. Tre gånger tidigare har loppet körts på Solvalla med vinnarna <strong>Särpefanten</strong> (1.16,7a), <strong>Ådne Odin</strong> (1.14,6a) och ifjol <strong>Smedsbo Faksen</strong> (1.17,5a).</p>



<p class="wp-block-paragraph">Den sistnämnde är med även i årets upplaga, där den mest meriterade hästen är femfaldige miljonären <strong>Smedheim Solan</strong> (e. Bork Odin).</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/05/smedsbofaksen4-617x333.jpg" alt="" class="wp-image-308068"/><figcaption class="wp-element-caption">Smedsbo Faksen vann fjolårets upplaga av Speedrace för kallblod. Idag kan han försvara sin titel. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p class="has-drop-cap wp-block-paragraph">3 Det finns ett travliv utanför Solvalla även i dessa Elitloppstider. Hagmyren (första start 18.20) och Kalmar (start 18.30) delar på kvällens tävlingar och det blir finfrämmande i Hälsingland.</p>



<p class="wp-block-paragraph">Daniel Redén mjukar upp inför Elitloppshelgen med att åka norrut med fjolårets Kriterievinnare <strong>Xanthis Harvey</strong> (e. Propulsion), som gör årsdebut i ett försök till fyraåringsloppet Norrland Grand Prix. Redén gjorde bokslut för säsongen efter triumfen på Solvalla i slutet av september efter sju starter (4-3-0) och drygt 4,3 miljoner kronor insprunget.<br>– <em>På sistone har han känts jättefin. Han har tränat väldigt tungt för att få ner honom på jorden och det känns bra nu. Vi börjar säsongen här och hoppas att han är fin i lopp också</em>, säger Daniel Redén på Stall Zets hemsida.</p>



<p class="wp-block-paragraph">Det bjuds fler godbitar på Hagmyren. I snabbloppet möter tolvårige <strong>Sorbet</strong> (e. Super Photo Kosmos), med ett lopp i kroppen efter nästan två års paus, bland annat <strong>Mellby Jinx </strong>(e. Ready Cash) och <strong>Jaguar Dream </strong>(e. Love You). Ett lopp för fem- och sexåriga kallblod till minne av förolyckade proffstränaren Roger N Olsson ser fjolårets norske Derbytvåa <strong>Holter Odin </strong>(e. Moe Odin) i årsdebut mot bra svenskt motstånd.</p>



<p class="wp-block-paragraph">I Kalmar gör treårige <strong>Fiddle Faddle </strong>(e. Nuncio) årsdebut. Hästen var segerlös i sju starter förra året, men tog femteplatsen i Breeders Course-finalen på 1.13,9ak och deltog i Svampen. Hästen startar i ett försök i Kalmars treåringsserie och det blir även ett försök för fyraåringar, där hemmaamatören Elisabeth Almhedens talang <strong>A Fair Day</strong> (e. Maharajah) jagar tredje raka segern.</p>



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



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



<p class="has-drop-cap wp-block-paragraph">4 Kvällens Grupp III-lopp Prix Jean Riaud (€90.000) på Vincennes (första start 18.58) har samlat ett så pass starkt startfält att det inte är överord att påstå att närmare en handfull av deltagarna hade kunnat starta i Elitloppet!</p>



<p class="wp-block-paragraph">Prix d&#8217;Amerique-favoriten <strong>Idao de Tillard</strong> (e. Severino) gör vårcomeback tillsammans med Clément Duvaldestin, Lotteriatrean <strong>Capital Mail</strong> (e. Nad Al Sheba) görs på nytt av Gabriele Gelormini och Prix ducs de Normandie-tvåan<strong> Hokkaido Jiel </strong>(e. Brillantissime) finns med tillsammans med David Thomain.<br>Som om inte det vore nog så jagar Jean-Michel Bazires formsökande, men ack så grundkapable <strong>Elie de Beaufour </strong>(e. Royal Dream) från 25 meters tillägg.</p>



<p class="wp-block-paragraph">Fem hästar med blågul koppling startar likaså på den franska nationalarenan. I femåringsloppet Prix Constellation (€60.000) möts Vitale Ciotolas svenskfödde <strong>Cabasse</strong> (e. Readly Express) samt Jörgen Westholms <strong>Beat Generation</strong> (e. Bird Parker).<br>I Prix Mutus (€52.000) för sju- till nioåriga hästar av &#8221;silverklass&#8221; startar Björn Goop såväl <strong>Gaylord Am</strong> (e. Muscle Hill) som <strong>Cruise</strong> (e. Enjoy Lavec) och i det inledande Grupp III-loppet Prix Caecilia (€70.000) för fyraåringar bidrar Jarmo Niskanen med Joyful Diva (e. Sam Bourbon).</p>



<p class="wp-block-paragraph">En svensktränad häst syns även vid lunchtävlingarna i Meslay-du-Maine (första start 11.50). Tomas Malmqvists <strong>El Messie Joroco</strong> (e. Laetenter Diem) startar i amatörloppet Prix des Amateurs (€6.000) och körs av Louis Pejus i jakt på årets första seger.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/00228343008scoopdyga-617x411.jpg" alt="" class="wp-image-430934"/><figcaption class="wp-element-caption">Jörgen Westholm-tränade Beat Generation segrade i Prix Ariel (€60.000) på Vincennes i april. Idag jagar han ny seger på kolstybben. Foto: Scoopdyga.</figcaption></figure>



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



<p class="has-drop-cap wp-block-paragraph">5 Halmstadtränaren Håkan K Persson har fått in en V75-vinnare i sitt stall. Det handlar om den tyskfödde valacken<strong> Herman Hazelaar</strong> (e. Creatine) 1.12,1ak/496.699 kr som under fjolåret vann ett fyraåringslopp under Axevallas Stochampionatsdag med 100.000 kronor i förstapris på urstarka 1.13,3/2.160 meter.<br>Då i regi Jenni H Åsberg, men efter att femåringen nu inlett med en andraplats som bästa resultat på årets fyra första starter så blir det nu Halmstadtränarens uppgift att försöka få tillbaka springaren på vinnarspåret.</p>



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



<p class="has-drop-cap wp-block-paragraph">6 Idag avgörs Danskt Mästerskap för ston i Odense (första start 15.45) och det sker med svenska intressen.<br>Björn Lindblom-tränade <strong>Eight Hour </strong>(e. Ganymede) kommer till start från ett perfekt andraspår bakom startbilsvingen och därtill agerar Jörgen Sjunnesson kusk bakom Peter Falcks <strong>Excellent Torkdahl </strong>(e. Ens Snapshot).</p>



<p class="wp-block-paragraph"><strong>Startlista Danskt Mästerskap för ston</strong><br><em>2.140 meter autostart, förstapris: 100.000 danska kronor</em></p>



<ol class="wp-block-list">
<li>Gonnabe Shadow – Birger Jörgensen</li>



<li>Eight Hour – Ken Ecce</li>



<li>Global Yankee – Jeppe Juel</li>



<li>Gaby C N – Rene Jonassen</li>



<li>Farinelli Hastrup – Sören Demant Andersen</li>



<li>Excellent Torkdahl – Jörgen Sjunnesson</li>



<li>Gaby Kyvsgård – Nicklas Korfitsen</li>



<li>Eagle Bat – John Köhler</li>



<li>Golden C N – Bent Svendsen</li>



<li>Eenymeenyminymoe – Flemming Jensen</li>



<li>Go On Gardenia – Knud Mönster</li>



<li>EA – Jeppe Rask</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">7 Även om det är sporten som står i centrum under Elitloppshelgen så drar givetvis även spelet till sig stort intresse.</p>



<p class="wp-block-paragraph">Sulkysport arrangerar som vanligt andelsspel hos Andelskungen till helgens V75-omgångar och du som vill köpa andel i våra system kan ta del av utbudet nedan.</p>



<p class="wp-block-paragraph"><strong><em>V75 lördag 27 maj:</em></strong></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2023-05-27_5_5" target="_blank" rel="noreferrer noopener">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-05-27_5_5" target="_blank" rel="noreferrer noopener">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-05-27_5_5" target="_blank" rel="noreferrer noopener">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<p class="wp-block-paragraph"><strong><em>V75 söndag 28 maj:</em></strong></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2023-05-28_5_5" target="_blank" rel="noreferrer noopener">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-05-28_5_5" target="_blank" rel="noreferrer noopener">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-05-28_5_5" target="_blank" rel="noreferrer noopener">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>

Fokustema
Morgonsvepet
Läs senare
Spännande smygstart
Om dagens "smygstart" av travfesten på Solvalla kan du givetvis läsa i morgonsvepet, men vi lyfter även fram Prix d'Amerique-favoritens comeback på Vincennes samt att det finns blågula intressen i Danskt Mästerskap för ston.
