
<p class="has-drop-cap">1<strong>Riverdale Z. </strong>(e. Maharajah) vann förra veckan på 1.09,4a/1609 meter på milebanan – årets snabbaste tid i Sverige. <strong>Francesco Zet</strong> (e. Father Patrick) tog hem Paralympiatravets final över medeldistans på 1.09,5a – bara ”Frasse” själv har travat snabbare över distansen på tusenmetersbana med 1.09,4a.</p>



<p>Är det dags för en ny häst att kliva upp på listan över årets snabbaste travare 2026? Prins Daniels lopp har tappat direktplatsen till Elitloppet, men chansen är god att dagens vinnare i gulddivisionsfinalen får chansen i Elitloppet. Det är sista loppet i nyinstiftade E-loppsserien, där två rosa biljetter ligger i potten. Den ena har <strong>Don Fanucci Zet</strong> (e. Father Patrick) redan säkrat, men striden om den andra är öppen.</p>



<p>Daniel Redéns minitravet <strong>Keep Asking</strong> (e. Chyapter Seven) mäter blott 146 centimeter över manken och kostade 160.000 dollar på Harrisburgs mixedauktion hösten 2024. Sedan han kom till Daniel Redén har hingsten inte varit sämre än tvåa på nio starter, varav sju slutat med seger.<br>Nu jagar han ytterligare en triumf som nedstruken till fjärdespår – titelförsvararen <strong>Global Etalon</strong> (e. Brillantissime) är struken för hälta – och Keep Asking har inlett säsongen med två raka starter på 1.10,2ak.<br>– Keep Asking var bra i Finland-Ajo som tvåa, men jag tror han var lite märkt av resan för han var inte alls så startsnabb som han kan vara och lite loj även att gå upp i rygg. Han verkar i alla fall pigg och glad här hemma efter hemkomsten och måndagsjobbet var fint så jag tror formen sitter där. Läget blev perfekt och uppgiften gillar jag så det blir intressant. Barfota runt om och bike som vanligt, säger Daniel Redén till sin hemsida <a href="http://reddis.se">reddis.se</a>.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/05/23v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Gävles tävlingar.</a></p>


<div class="factbox full ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Ställningen i E-loppen								</h3>
<div class="content">
<p><strong>Efter sex lopp:</strong><br /><em>Häst – Tränare – Poäng</em></p>
<ul class="wp-block-list">
<li><strong>Don Fanucci Zet – Daniel Redén – 30</strong></li>
<li>Barack Face – Lutfi Kolgjini – 15</li>
<li><strong>Borups Victory – Daniel Wäjersten – 15</strong></li>
<li><strong>Diva Ek – Alessandro Gocciadoro – 15</strong></li>
<li>Francesco Zet – Daniel Redén – 15</li>
<li>Hades de Vandel – Paul Hagoort – 11</li>
<li><strong>Jobspost – Jörgen Westholm – 8</strong></li>
<li>Kuiper – Daniel Wäjersten – 8</li>
<li>Mellby Jinx – Daniel Wäjersten – 8</li>
<li>Parveny – Mattias Djuse – 8</li>
<li>Önas Prince – Per Nordström – 8</li>
<li><strong>A Fair Day – Elisabeth Almheden – 6</strong></li>
<li>Double Deceiver – Daniel Redén – 6</li>
<li>Castor the Star – Jörgen Westholm – 6</li>
<li><strong>Gio Cash – Daniel Wäjersten – 6</strong></li>
<li>High On Pepper – Katja Melkko – 6</li>
<li>Kentucky River – Daniel Redén – 6</li>
<li>Laredo Boko – Robert Bergh – 6</li>
<li>Get A Wish – Robert Bergh – 3</li>
<li>Steady Roc – Krister Olsson – 3</li>
<li>Xanthis Harvey – Daniel Redén – 3</li>
<li>Queen of Power – Fredrik Persson – 2</li>
<li>Corazon de B. – Per Lennartsson – 2</li>
<li>Following – Stefan Melander – 2</li>
<li>Gamin Jaba – Daniel Redén – 2</li>
<li>Luke The Spook – Adrian Kolgjini – 2</li>
<li>Stens Rubin – Johan Untersteiner – 2</li>
<li>Bicc&#8217;s Tobee – Maria Törnqvist – 1</li>
<li>Eolo Jet – Alessandro Gocciadoro – 1</li>
<li>Joe Dalton – Stefan P Pettersson – 1</li>
<li>Macahan – Maria Törnqvist – 1</li>
<li><strong>Charron – Geir Vegard Gundersen – 1</strong></li>
</ul>
<p><strong>Hästar i fet stil är redan inbjudna till/klara för Elitloppet 2026.</strong></p>
<p><strong>Fotnot: </strong>Poäng utgår till de sex främsta hästarna enligt skalan: 15-8-6-3-2-1.<br />Vid lika poäng avgör antal starter i loppen. Vid lika antal starter avgör lottning.<br />De två främsta i serien får en biljett till Elitloppet.</p>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>



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



<p class="has-drop-cap">2Det drar ihop sig för Elitloppshelgen, men först väntar en jackpotomgång på V85 i Gävle i eftermiddag. Drygt 19 miljoner kronor extra ligger i dagens åttarättspott, som spås landa på mionst 41 miljoner kronor.</p>



<p>Delar av Sulkysports expertpanel tror hårt på Keep Asking, medan andra hittat andra vägar för att få åtta rätt. Som en kallblodsspik i ett av två V85-lopp för den kalla rasen i Gävle:<br><em>”<strong>Palmesus N.O. </strong>jagar sjätte raka segern och kommer hit med totalt elva segrar på 27 starter. En av världens bästa kallblodskuskar Mats Djuse rattar favoriten igen. Trots bra motstånd och många att runda ser det ut som en riktigt toppchans och jag spikar,” </em>skriver Simsalabims expert Fredrik Persson.</p>



<p>Kallblodsloppet är namngivet Gunnar Wallbergs Minne. Gunnar var 15-faldig kuskchampion på hemmabanan Gävle 1956-1972. Han firade framgångar med hästar av båda raserna, men på hösten 1967 skrev han historia när Solels (e. Solo) blev första svenska kallblod att trava under 1.30 i voltstart.</p>



<p>Första segern tog Wallberg med pappa Göstas Rexie Blank och totalt blev det 1.058 kusksegrar sedan han klivit in i ”tusenklubben” 1984 efter seger på hemmaplan med Mr Vanadis. Bland duktiga travare från karriären kan Farga, Lugano, Morris, Tom Brunnby och Stochampionatsvinnaren Sweet Janki nämnas.</p>



<p><a href="https://sulkysport.se/spelstugan/v85-jackpot-nu-ar-det-dags/" target="_blank" rel="noreferrer noopener">––> Här är experternas tips till Gävles V85-omgång.</a></p>



<p><em>Vill du spela andelsspel tillsammans med Sulkysports panel? Här finns olika alternativ:</em></p>



<p><a href="https://www.atg.se/butik/simsalabim/V85_2026-05-23_16_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Simsalabim.</a></p>



<p><a href="https://www.atg.se/butik/69ansspel/V85_2026-05-23_16_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos 69:ans Spel &#038; Tobak.</a></p>



<p><a href="https://www.atg.se/butik/spelpoolen/V85_2026-05-23_16_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Spelpoolen.</a></p>



<p>Innan jackpotfesten i Gävle drar igång blir det breddlopp på två andra svenska banor. Jägersro (första start 11.10) och Umåker (start 12.30) bjuder på åtta lopp vardera.</p>



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



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/04/villestgratien2-617x379.jpg" alt="" class="wp-image-839776"/><figcaption class="wp-element-caption">Alexandre Abrivard och Ninepoints Lasse spurtar till vinst i näst senaste starten. Foto: Gerard Forni</figcaption></figure>



<p class="has-drop-cap">3Hans R Strömberg och svärsonen Jörgen Westholm står bakom de svenska hoppen på dagens franska huvudbana, Enghien (första start 13.23) i Paris i eftermiddag.</p>



<p>I eftermiddagens största lopp Prix de l’Obelisque (€75.000) över 2.150 meter autostart kliver Uncle Lasse-sonen <strong>Ninepoints Lasse</strong> ut från spåret längst ut bakom bilvingen. Alexandre Abrivard kör hästen, som vann sin senaste sulkystart på just Enghien för en dryg månad sedan innan han galopperade bort sig i monté i Caen. </p>



<p>Nästan lika mycket pengar tävlar bestor Strömbergs sto <strong>Xerava C.D.</strong> (e. Uncle Lasse) om i Prix du Rhone (€71.000), där hon dragit andraspår bakom bilen tillsammans med Gabriele Gelormini. Två svenskfödda utmanare startar från bakspår. <strong>Nelson Greenwood</strong> (e. Tobin Kronos) och <strong>Omerta Boko</strong> (e. Face Time Bourbon).</p>



<p>Det tredje svenska bidraget är Westholms <strong>Cameron</strong> (e. Maharajah) i montéloppet Prix du Pont du Garigliano (€59.000), där Alexandre Abrivard sitter i sadeln. Svenska duon <strong>Rossi Garline</strong> (e. Readly Express) och <strong>Silver Bullit</strong> (e. Orlando Vici) är två av motståndarna.</p>



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



<p class="has-drop-cap">4Norske proffstränaren Lars Magne Sövik har tagit över 1.000 tränarsegrar och hans hästar sprungit in nästan 54 miljoner kronor, men nu sätter han punkt för karriären. Fyraåriga stoet <strong>A View To A Kill</strong> (e. Trixton) på hemmabanan Jarlsberg idag blir hans sista start som tränare.<br>– Jag har opererat hjärtat två gånger och ska opereras igen i sensommar. Läkaren sa att nästa gång jag faller kommer jag inte att resa mig upp igen. Jag har också problem med en arm som gör det svårt att köra häst, särskilt starka hästar. Det är helt enkelt min hälsa som stoppar mig, säger Lars Magne Sövik, 65, till Trav- og Galopp-Nytt.</p>



<p>Svenskfödda A View To A Kill har vunnit sju av elva starter sedan hon köptes till Norge och sattes i träning hos Lars Magne Sövik förra hösten.</p>



<p>Norrmannens största tränarseger kom 2002 genom <strong>Hot Chili Pepper</strong> (e. Express Ride) i norska Kriteriet.<br>– Jag har varit med länge och är väldigt nöjd med min karriär. Det har varit många höjdpunkter genom åren, säger Lars Magne.</p>



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



<p class="has-drop-cap">5Från domarchef på Svensk Travsport till vice dito – och till verksamhetschef på Axevalla. Jonny Staf har fått ett nytt uppdrag som shan tillträder i augusti. Axevallas vd Roger Moström berättar att verksamheten runt Axevallatravet växer och i höst tillträder Staf som verksamhetschef.</p>



<p><em>”Vi behöver skapa förutsättningar i organisationen för fortsatt tillväxt och rekrytering av nya in i sporten. Unga i travskolan, aktiva, hästägare och publik behöver bli fler och det krävs att vi tillsätter resurser för det för att kunna lyckas”, </em>skriver Axevalla.<br>– Jag har haft flera olika roller på Axevalla under lång tid, det började med ett sommarjobb efter nian. Efter sex år på Svensk Travsport och en sejour tillbaka i skolans värld ser jag nu fram emot denna nya roll på Axevalla. I min nya roll hoppas jag kunna bidra till fortsatt positiv utveckling för banan, säger Jonny Staf i ett pressmeddelande.</p>



<p>Staf lämnade Svensk Travsport efter att ha arbetat i sex år med domarfrågor. Förra vintern blev han nedflyttad från posten som domarbas till vice domarchef när Erik Adielsson anställdes som domarbas.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/05/bravoangel1552026lisa-617x346.jpg" alt="" class="wp-image-850714"/><figcaption class="wp-element-caption">Invändiga Bravo Angel håller undan för Miracle Maven. Foto: Lisa Photo</figcaption></figure>



<p class="has-drop-cap">6Femte raka segern jagar svenskfödda <strong>Bravo Angel</strong> (e. Readly Express) i ett försök i Miss Versatility ($30.000) på Meadowlands i natt. Men Per Engbloms sto ställs inte mot det enklaste motstånd. Åke Svanstedts dubbla Breeders Crown- och Hambletonian Oaks-vinnare <strong>Warrawee Michelle</strong> (e. Walner) årsdebuterar i samma lopp.</p>



<p>På Meadowlands bjuds också på första försöksrundan i New Jersey Sire Stakes ($25.000) för treåringar och det vimlar av svensktränade travare. I stonas uppgörelser är åtta svensktränade, medan hingstarna/valackers försök innehåller blott fyra hästar. </p>



<p><a href="https://racing.ustrotting.com/goto.aspx?target=12,103938" target="_blank" rel="noreferrer noopener">Startlistorna till Meadowlands tävlingar hittar ni här.</a></p>



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



<p class="has-drop-cap">7Den 13 september går vi svenskar till val. Då ska det röstas i kommun-, region- och riksdagsval och det blir stort fokus på detta hela vägen fram till valdagen.</p>



<p>Spelbolaget ATG har hittat ett sätt att vägleda svenska folket, genom att erbjuda en valbarometer där man kan fylla i sina åsikter som sammanställs och ger förslag på vilket parti som passar bäst utifrån svaren enligt ATG:s egna valbarometer Hästvalet 2026.<br>– Hästvalet visar att partierna i grunden delar synen på hästnäringens betydelse, men att de skiljer sig åt i frågor som rör skatter, offentligt stöd och vilken roll politiken ska spela för näringens framtid, säger Camilla Hasselström, chef för Public Affairs på ATG.</p>



<p>ATG skriver i ett pressmeddelande att valkompassen har tagits fram av Demoskop på uppdrag av ATG. Riksdagspartierna har fått ta ställning till samma frågor som presenteras i valkompassen Hästvalet 2026. Frågorna skickades skriftligt till partierna under april och maj 2026. Samtliga riksdagspartier inkom med svar, och flera partier valde även att kommentera sina ställningstaganden. Innan valkompassen publicerades fick partierna möjlighet att ta del av och, om önskvärt, justera sina svar.</p>



<p><a href="https://omatg.se/hastvalet2026/" target="_blank" rel="noreferrer noopener">Här kan du själv göra enkäten i Hästvalet 2026 med 15 frågor om hästsport, landsbygdsutveckling och hästnäringens framtid.</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
Sista chansen till Elitloppet
Dukat för fartfest i Gävle? Westholm och Strömberg i Paris. Förre domarbossens nya uppdrag. Tusenklubbare lämnar in licensen med hjärtproblem. ATG ger sig in i politiken.
Detta och mer i lördagens ”Sju nyheter vid sju”.
