
<p class="has-drop-cap wp-block-paragraph">Det bjuds på stor travsport på Åby under lördagen med tre Grupp I-lopp inom V75-kupongen.<br>Vi väljer att spika <strong>San Moteur </strong>(V75-7) i Paralympiatravets final då vi helt enkelt bedömer honom att vara huvudet högre än sina konkurrenter, men garderar i de två Pokalfinalerna.</p>



<p class="wp-block-paragraph"><strong>Joviality</strong> (V75-2) blir stor favorit i Drottning Silvias Pokal och har häftiga meriter i bagaget. Sverigedebuten lovade mer, men nu kan hon komma att ställas inför en helt annan prövning över en distans som alltjämt är ovan för henne och det går inte med säkerhet säga hur en resa utvändigt ledaren exempelvis skulle påverka henne.</p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://sulkysport.se/gocciadoro-annu-battre-nu/" target="_blank"><strong><em>>> Läs även: Gocciaodoro: &#8221;Ännu bättre nu&#8221;</em></strong></a></p>



<p class="wp-block-paragraph">Vi betalar för sex hästar i det loppet, tar en trio i Kungapokalen (V75-4) och chansspikar istället i Bronsdivisionen.<br><strong>Inspiration</strong> (V75-5) flög fram i spurten flera gånger i STL-sammanhang ifjol och har alla möjligheter att komma igenom fint från bakspår i ett lopp som vi tror kan bli tempostarkt med flera startsnabba hästar i första ledet.<br>När Joakim Lövgrens häst blott är spelad på fem procent känns det helkul att chansa på honom som spik och på så vis skaffa sig en helt annan potential i systemet än vad många spelare kommer ha på sina kuponger.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/05/06v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna på Åby.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



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



<h2 class="wp-block-heading">Avd 1 – Lyon Grand Prix, 2.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Mellby Jinx </strong>har inlett på bästa tänkbara sätt i Daniel Wäjerstens regi. I årsdebuten speedade han till vinst via vinnarhålet, i efterföljande Paralympiatravskval avslutade han strålande från fjärde utvändigt som knappt slagen av Milliondollarrhyme via 1.08,5 sista 800 meterna och Kjell P Dahlströms Minne togs hem med en gäspning från ledningen. Det var gott för honom att inte behöva spela ut hela registret den dagen och det behöver inte heller vara negativt för honom att ha bakspår här och kunna spara på krafterna istället för att få en tuff öppning över lång distans.</li>



<li><strong>Kentucky River </strong>avslutade oerhört vasst på open stretch i årsdebuten och det var sånär att han hann förbi Behind Bars. I det efterföljande Silverdivisionsförsöket överraskade han dock allt och alla genom att galoppera från start och så var den dagen förstörd. Per Nordströms häst såg jättefin ut inför loppet så vi inte är inte oroliga kring formen, men däremot kan en eventuell safetystart här efter senaste felstegen bli kostsam då det kan utmynna i en tuff resa utvändigt ledaren.</li>



<li><strong>Edibear</strong> var trea i Svenskt Travderby ifjol och stod för en mersmakande årsdebut. Han kördes precis som annonserats passivt och behövde bara sträcka ut sista 200 meterna, men han avslutade verkligen vasst med 1.10,8 sista varvet. Make it Happen-sonen är inte startsnabb och lär bli över från start, men en vilsam invändig resa är sällan fel på Åby.</li>



<li><strong>Usain Lobell</strong> vann uttagningslopp till Kungapokalen ifjol och slutade tvåa i finalen av Tyskt Travderby. Han avslutade 1.09,5 sista 700 meterna från andra utvändigt i årsdebuten och var på intet vis dålig, men det känns alltjämt som det finns mer att ta av än vad Bold Eagle-sonen får ut just nu.</li>



<li><strong>Power Doc </strong>trodde vi stenhårt på i lördags, men då valde Åke Lindblom att sitta kvar i andraspår när &#8221;tåget&#8221; gick dryga varvet före mål. När Muscle Massive-sonen väl tog sig loss gick benen fort och när han nu står med framspår och det inte kryllar av startraketer så finns det viss chans att han kan vinna starten.</li>



<li><strong>Invictus Madiba </strong>avslutade 1.07,7 sista 800 meterna som tvåa bakom Callmethebreeze vid fjolårets start i Fyraåringseliten. Fuxen har verkat förtvivlat trött på att springa på Vincennes ju äldre han blivit och det kittlar verkligen att han är tillbaka på svensk mark. Avslutningen senast i Cholet som är en platt bana bakom meriterade Gitano lovade mer och hästen känns helt klart skrällduglig.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>9-4 <strong>B:</strong> 1-6-5-10-7-3 <strong>C:</strong> 11-2-8-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Edibear</strong> är ingen raket från start och får svårt att hålla upp innerspåret. Såväl <strong>Kentucky River </strong>som <strong>Power Doc</strong> tycker vi har öppnat som bäst när de stått med spår bakom eller lite längre ut vid bilen. Kan den sistnämnde rentav smita förbi om inte Per Nordström vågar maxladda med sin häst efter senaste galoppen&#8230;?</p>



<h2 class="wp-block-heading">Avd 2 – Drottning Silvias Pokal, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Joviality</strong> har överlägsna meriter gentemot sina konkurrenter i detta lopp och det är fullt möjligt att det är så enkelt att hon bara vinner. Intrycket i Sverigedebuten var verkligen tilltalande då hon joggandes avslutade 1.10 sista 700 meterna efter att släppts till ledningen på första långsidan. Här är det dock inte lika givet att hon &#8221;framvinkad&#8221; om värsta motståndaren lyckas hålla upp ledningen och hur Joviality agerar om hon skulle få springa på utsidan över drygt två kilometer är det ingen som vet med säkerhet.</li>



<li><strong>Riverdale Z. </strong>fick god hjälp med tempot av sina konkurrenter i kvalloppet, men som hon såg ut så hade de nog kunnat lulla på i snigelfart fram tills mitt på upploppet och ändå fått se sig besegrade av henne. Sättet hon svepte fram på över sista bortre långsidan var verkligen läckert och klockan visade 1.10 för hennes sista 800 meterna. Gången innan gjorde hon debut bakom startbilen och uppförde sig då ytterst förnuftigt och tog ledningen med lätthet. Hur Conrad Lugauer gör om han vinner starten står skrivet i stjärnorna, men det kittlar verkligen att se Riverdale Z. få löpa ut i ledningen&#8230;</li>



<li><strong>O&#8217;Mara Zon </strong>fick ingen bra start på året då hon ströks inför den tilltänkta årsdebuten, men nu verkar hon åter ordentligt på gång. Hon såg urläcker ut i kvalet när hon spänstade undan på barfotabalans framme i tät och hon lär ta ytterligare steg på formstegen med två lopp i kroppen.</li>



<li><strong>Mellby Korall </strong>fick en tuff inledning av sitt försökslopp innan hon blev avlöst, men krigade ändå på hela vägen in till linjen via 1.09 sista 700 meterna. Det var en riktigt bra prestation och för oss kittlar det att se om hon lägger i ytterligare en växel nu när hon får på sig ett norskt hvuudlag för första gången.</li>



<li><strong>Kayla Westwood</strong> avlöste Mellby Korall halvvägs in i kvalloppet och höll undan till vinst med en halv längd. Hon är tveklöst bra och har prenumererat på biljetter till storloppsfinaler, men väntar alltjämt på den stora segern.</li>



<li><strong>Stens Retention </strong>kunde inte riktigt haka på Riverdale Z. på slutvarvet i kvalet, men höll farten väl som tvåa. Hon flög till tät i fjolårets Breeders Crown-final och Peter Untersteiner bör rimligen jaga en position långt fram i fältet även denna gång när han står med öppet spår.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 4 <strong>B: </strong>1-2-5-3-6 <strong>C: </strong>9-11-7-10-8-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Riverdale Z. </strong>har bara haft framspår vid ett tillfälle och då tog hon ledningen enkelt. Vi tror hon håller ut <strong>O&#8217;Mara Zon </strong>och <strong>Kayla Westwood</strong>, men utifrån lär <strong>Stens Retention</strong> som frontade i Breeders Crown-finalen samt mycket raska <strong>Lawina</strong> skickas med full kraft.</p>



<h2 class="wp-block-heading">Avd 3 – Klass II, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Winner Brodde</strong> blir vårt tipsval i detta Klass II-lopp som inte känns helt lättlöst. Han har inlett året med två övertygande segrar efter forcering till tät en bit in i loppen och klivit undan väldigt bestämt i slutskedet. Näst senast på Åby tvingades han varva på 1.12,8, men det spelade ingen roll utan han stod likväl distansen den dagen. Nu växlar man upp till barfota runt om och även om han &#8221;bara&#8221; har en seger samt en andraplats på de fem tidigare försöken på den balansen så bedömer vi det som ett plus.</li>



<li><strong>Hardcore D.K. </strong>är stallkamrat och ett hopp för danska derbyt i Untersteiners stall. Han såg jättefin ut vid fjolårets segrar och då framförallt vid de två avslutande där han lämnade sina konkurrenter med lätthet från ledningen via snabba slutvarv. I årsdebuten på Jägersro fick han långt fram från fjärde utvändigt och det såg inte ut som att körande Stefan Persson pressade hästen mer än nödvändigt i spurten när det ändå inte gick att utmana om topplaceringarna. Det loppet för säkert fram Propulsion-sonen och nu är han anmäld barfota bak för första gången.</li>



<li><strong>Peter Pan </strong>har aldrig varit sämre än trea i sina fem första starter och känns likaså talangfull. Han förlorade årsdebuten från ledningen, men behövde helt enkelt den &#8221;ursotaren&#8221; som det såg ut för han var rejält förbättrad redan i efterföljande start där han var stor i nederlaget som dödenstvåa. Nu har Björn Goop anmält hästen barfota runt om vilket i sådana fall blir första gången i lopp om han fullföljer på den linjen.</li>



<li><strong>Yavapai Point </strong>har vi inte riktigt tagit till oss tidigare, men nu ser det ut att ha hänt mycket saker på sistone. Hästen fick chansen för sent näst senast på Solvalla, men sköt till rappt som obrukad femma i en final av Solvallaserien 150 och senast på samma bana gick han undan snyggt efter att kommit igenom bra från bakspår och hittat till tät i tidigt skede. Efter att utrustats med jänkarvagn uppfattar vi hästen allmänt rappare och blir inte överraskade om han når ledningen trots spår sju i ett lopp där startkanonerna lyser med sin frånvaro.</li>



<li><strong>Jonathan Star </strong>har verkligen funnit stilen på sistone och tagit tre raka segrar. De två senaste är tagna från dödens varav triumfen på Bjerke togs via 1.12,8 sista varvet. Han tävlade barfota runt om vid V75-segern på Orkla näst senast och är anmäld med den balansen på nytt vilket såg ut att ge skön kick i steget på Born in the U.S.A.-sonen. Från spår tolv får han inte plats i vår A-grupp, men vi räknar på intet vis bort honom.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>5-9-10-7 <strong>B:</strong> 12-2-4 <strong>C: </strong>11-6-3-1-8</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Lurigt värre då ingen av framspårshästarna visat prov på någon häftig startsnabbhet såhär långt. <strong>Yavapai Point</strong> öppnade riktigt bra från bakspår senast på Solvalla och kom snabbt fram som tredjehäst. Vi tror att Jörgen Westholm ger sig på ett allvarligt försök att trycka sig hela vägen till tät.</p>



<h2 class="wp-block-heading">Avd 4 – Konung Gustaf V:s Pokal, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Dancer Brodde </strong>avslutade treåringssäsongen med att spåra hem Breeders Crown-finalen och han står inför exakt samma förutsättningar här med bricka ett. Intrycket i kvalet var sådär skönt flegmatiskt fram tills Johan Untersteiner bad hästen lägga i nästa växel och då gick han ifrån sina motståndare enkelt. Från tät är Bold Eagle-sonen hästen att slå för de övriga.</li>



<li><strong>Tetrick Wania</strong> har lyft för varje start i Conrad Lugauers regi och ser ut att vara på väg tillbaka och bli den där storstjärnan han förutspåddes bli som tvååring. I försöket kunde Lugauer köra sig till tät in på slutrundan och det såg ut att finnas en hel del sparade krafter i Muscle Hill-sonen när han gick ifrån till vinst på 1.11,8a/2.140 meter. Oavsett hur Tetrick Wania hamnar till positionsmässigt här så tror vi att han är med och strider om segern.</li>



<li><strong>Bedazzled Sox</strong> fick bestämma farten i ledningen i kvalet och det var tacksamt för hans del att inte behöva spela ut hela registret. Han är intet beroende av någon särskild position utan känns likt Tetrick Wania aktuell för slutstrid vart han än hamnar.</li>



<li><strong>Following</strong> nådde ledningen i sitt kval och tangerade Tetrick Wanias segertid på 1.11,8a/2.140 meter. Gången innan fick han kriga på utan rygg i tredjespår de sista 1.200 meterna och höll strålande som tvåa. I fjolårets Breeders Crown-final fick han vinnarhålet på Dancer Brodde och chansen över spurtrakan, men lyckades inte ta sig förbi.</li>



<li><strong>Hustle Rain</strong> tycker vi höll storstilat utvändigt om Bedazzled Sox i kvalet där han avslutade 1.10 sista varvet. Då <strong>H.C.&#8217;s Crazy Horse</strong> passerade honom i sista steget får han inleda finalen från spår åtta, men när Mattias Djuse växlar upp och kör barfota runt om för blott andra gången kan vi inte låta bli att ha Hustle Rain högt upp i ranken.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>1-4-3 <strong>B: </strong>2-8-11 <strong>C: </strong>10-9-6-7-12-5</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Dancer Brodde</strong> höll upp innerspåret i Breeders Crown-finalen ifjol. Vi bedömer honom ha god chans att så göra på nytt när han står sida vid sida med <strong>Following</strong> och <strong>Bedazzled Sox</strong>. Utifrån är <strong>Thereisnolimit</strong> och <strong>Ante La Roque </strong>hästar som kan lägga iväg bra och rimligen vill ta sig ner i fina positioner.</p>



<h2 class="wp-block-heading">Avd 5 – Bronsdivisionen, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Inspiration</strong> väljer vi att chanstippa i detta bronsförsök. Han gick lägga en häftig speed över sista bortre långsidan i sitt Bronsdivisionsförsök på Jägersro i jakten på att nå ifatt Bottnas Idol, men hann aldrig utgöra något allvarligt hot. Sista 50 meterna började det ta emot ordentligt, men det var inte konstigt med tanke på att det var hans blott andra start efter uppehåll samt utifrån vilken speed han hade lagt. Här har han rygg på en mycket startsnabb häst, kan sitta långt fram i fältet när det drar ihop sig och då kommer han hans avslutning bita bra. Låt oss påminna om att han vann två Klass I-försök ifjol från köposition och fullkomligen flög fram så detta är en riktigt vass spurtare.</li>



<li><strong>Heroine Darling </strong>fick nöta dödens på So Far Away ås senast på Solvalla och höll bra som trea med tanke på att det loppet inleddes i 1.08,5-tempo första halvvarvet. Hon har verkligen inte fått något gratis i här senaste starterna utan fått gå den tunga vägen, men inget tyder på att den långvariga form hon haft är på väg att peka neråt. Denna gång är hon anmäld med jänkarvagn vilket i sådana fall blir första gången i loppp.</li>



<li><strong>Dallas</strong> var oerhört bra vid försök samt finalseger i Solvallaserien. Först löste han en sprinteruppgift från dödens och därefter spårade han hem finalen lekande lätt. I senaste bronsförsöket på Axevalla fick han jaga från femte utvändigt i en tempofattig tillställning, men höll farten mycket bra via 1.09,8 sista 800 meterna. Vinner han starten här är han hästen att besegra för de övriga.</li>



<li><strong>Laredo Boko</strong> löste sin årsdebut från dödens och hade Global Concept på fall från samma position i bronsförsöket på Axevalla, men fick se sig utkontrad sista 50 meterna. Det var likväl en stark insats och han är en given segeraspirant på nytt även om spår sju kan bli utmanande att komma till från.</li>



<li><strong>Boli You S.M. </strong>kom inte iväg särskilt bra från springspår senast på Jägersro och när han därtill blev utan draghjälp genom slutkurvan så mattades han över spurtrakan. Nu är han tillbaka med jänkarvagn och Adrian Kolgjini har därtill anmält hästen barfota bak för första gången vilket kan ge skön effekt, men faktum kvarstår att hästen inleder från spår åtta och därifrån blir det inte enkelt att hitta en vettig position.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>10-2-3 <strong>B: </strong>7-8-1-11-4-5 <strong>C: </strong>9-6</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Dallas</strong> ska ha god chans att hålla ut <strong>Indigo</strong>. Enda hotet vi kan finna mot att den förstnämnde inte skulle sitta i tät är om vagnsbytet på <strong>Heroine Darling </strong>bättrar på hennes startsnabbhet så till den grad att hon kan hålla ut, men vi tvivlar på den saken.</p>



<h2 class="wp-block-heading">Avd 6 – Silverdivisionen, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>King of Everything </strong>har funnit en hysterisk form under senvintern och början av våren. Senast på Axevalla fick han anfallsorder från tredje utvändigt ut på sista bortre långsidan, tog sig snabbt fram utvändigt om ledaren och gick ifrån till enkel seger på nya banrekordet 1.10,4a/1.640 meter. Det loppet var rejält överpacat ska tilläggas, men Claes Svenssons sjuåring blev låg som en tax när han lade i överväxeln och då tävlade han inte ens med sin optimala balans barfota runt om! Det är det däremot tanken att hästen ska göra nu och utifrån senaste intrycket kan vi inte tippa emot hästen.</li>



<li><strong>Karat River</strong> tog gigantiska steg i sin utveckling under fjolårets andra halva och har inlett femåringssäsongen lika starkt. I årsdebuten mötte han inget märkvärdigt motstånd, men såg läcker ut då han rundade sina konkurrenter i tredjespår via 1.10,5 sista 700 meterna och senast i silverförsöket på Jägersro föll han med flaggan i topp som nosslagen efter att gått i dödens sista varvet i 1.11-fart. Här gör Muscle Hill-sonen debut över sprinterdistans, men han har bara blivit raskare i benen för varje start han gjort så det i sig är inget som oroar oss.</li>



<li><strong>Hidalgo Heldia </strong>fick en knalltuff inledning i silverloppet på Axevalla med tredjespår genom första kurvan innan han övertog taktpinnen. Det kostade en öppning på 1.06,2 första varvet och efter en varvpassering på 1.09,5 var det inte konstigt att han fick släppa King of Everything förbi sig. Det var strongt gjort av sexåringen att kriga på så pass att han höll till andraplatsen och kan inledningen bli något lugnare nu så är det inte alls omöjligt att det håller hela vägen.</li>



<li><strong>Akilles Face </strong>såg hur stark ut som helst framme i ledningen senast på Jägersro när han galopperade i ledningen 400 meter före mål. Det kan mycket väl ha varit segern som rök där och han är givetvis intressant i detta lopp utifrån det intrycket även om det finns risk för att han får både en och två hästar framför sig. Oavsett vilket är en invändig tripp alltid fördelaktig på Åby.</li>



<li><strong>Golden Guard </strong>går ifrån att varit en av förhandsfavoriterna i Silverdivisionen senast på Axevalla till att bli helt bortglömd denna gång. Han galopperade 350 meter före mål på väg mot spårbyte i det nämnda loppet på Axevalla och det tar vi inte så hårt på. Det finns möjlighet att detta lopp blir tempostarkt och då kan han ta många i spurten utgångsläget till trots.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>10-6-4 <strong>B:</strong> 1-11-12-2-5-8-3-7-9</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Akilles Face</strong> kan verkligen lägga iväg bra, men får svårt att hålla ut <strong>Hidalgo Heldia</strong>. Även <strong>Vitro Diablo</strong> är mycket startsnabb och bör rimligtvis laddas iväg i jakt på invändig position.</p>



<h2 class="wp-block-heading">Avd 7 – Paralympiatravet, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>San Moteur </strong>blir klar favorit i Paralympiatravets final och det tycker vi är korrekt. Det blev inte mycket till lopp i årsdebuten under långfredagen då han släpptes till tät halvvägs in i loppet, men intrycket var likväl gott. Därefter skulle han ha startat i Parakvalet på Jägersro den 22 april, men ströks på grund av feber. Rapporten säger att han bara stod över ett jobb och att allt snabbt varit sig likt igen kring rutinerna. Nu växlar man åter upp och låter Panne de Moteur-sonen tävla barfota bak vilket är ett plus och vi kan se den här lättränade hästen lösa årets första Grupp I-lopp på svensk mark för äldre hästar även om han får gå utvändigt ledaren.</li>



<li><strong>Mister Hercules </strong>fick se sig nerplockad från just tät av San Moteur i Jubileumspokalen ifjol, men hade dessförinnan fått en riktig tuff öppning som hade satt sina spår. Det verkade som hästen fick en &#8221;mental törn&#8221; av det loppet utifrån hur han presterade under säsongens avslutande starter, men nu är han tillbaka i toppslag på nytt. I årsdebuten avslutade han 1.09,8 sista varvet utan att brukas nämnvärt och Grupp I-klassade Seinäjoki Race löstes från dödspositionen på ett mycket övertygande vis. Även om det är svårt att läsa in Mister Hercules som anförare av det här loppet och lite svårt att säga med säkerhet hur hans väg fram kommer bli så känns han som den tydligaste utmanaren till San Moteur.</li>



<li><strong>Bilo Jepson</strong> slutade tvåa bakom Elitloppsklare Horsy Dream i ett lopp på Vincennes i oktober och var faktiskt favoritspelad den dagen. Han har fortsatt prestera på en hög nivå efter det genom en stark dödensinsats näst senast samt en duglig avslutning mot elithästar senast som femma. Bilo Jepson är härdad i tuffa gäng och kan få förnyad löplust nu när han slipper springa i uppförsbacken på Vincennes.</li>



<li><strong>Jimmy Ferro B.R.</strong> hade Alessandro Gocciadoro haussat upp inför Prins Carl Philips Jubileumspokal och han gjorde ingen besviken i loppet. En resa utvändigt ledaren var inget som hindrade Love You-sonens framfart och &#8221;gul kusk&#8221; tycks helt inne på att hans häst kan vara ytterligare förbättrad nu med senaste loppet i kroppen. Jimmy Ferro B.R. har visat att han klarar alla distanser och är flexibel vad det gäller löpningsupplägg.</li>



<li><strong>Cicero T.G. </strong>gav San Moteur en rejäl match i Lyon Grand Prix motsvarande tävlingsdag ifjol. Även om han fick se sig nerplockad av <strong>Hades de Vandel </strong>senast på Axevalla så tycker vi prestationen var duglig och bedömer honom som en av de hetare platskandidaterna.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>6 <strong>B: </strong>3-10-9-4 <strong>C: </strong>1-5-8-7-2</p>



<p class="wp-block-paragraph">Spetsstriden: <strong>Milliondollarrhyme</strong> har alla möjligheter att hålla ut <strong>Chapuy</strong> när de står sida vid sida. <strong>Mister Hercules</strong> är bra iväg, men ingen superraket och vi undrar om verkligen Fredrik B Larsson väljer hans rygg utan ordentlig strid.<strong> San Moteur</strong> löste Jubileumspokalen efter ett slutvarv på ledarens utsida och vi tror Björn Goop tar initiativ mitt i loppet även här.</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">
									V75-FÖRSLAGET 6 MAJ								</h3>
<div class="content">
<p class="wp-block-paragraph"><strong>Avd 1:</strong> 1,4,5,6,7,9,10 (3,11)<br /><strong>Avd 2: </strong>1,2,3,4,5,6 (9,11)<br /><strong>Avd 3:</strong> 5,7,9,10,12 (2,4)<br /><strong>Avd 4: </strong>1,3,4 (2,8)<br /><strong>Avd 5: </strong>10 Inspiration (2,3)<br /><strong>Avd 6: </strong>1,4,6,10,11,12 (2,5)<br /><strong>Avd 7: </strong>6 San Moteur (3,10)</p>
<p class="wp-block-paragraph"><em>3.780 rader / 1.890 kronor</em></p>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
