
<p class="has-drop-cap wp-block-paragraph">Veckans V75-omgång håller hög sportslig klass då inte mindre än tre Grupp I-lopp tar plats inom kupongen.</p>



<p class="wp-block-paragraph">Ofta innehåller den typen av loppen någon stor favorit, men så är inte alls fallet denna gång utan strecken sprids av spelarna i merparten av de loppen.</p>



<p class="wp-block-paragraph">Även vi garderar på och finner istället singelstrecket i Klass II-försöket. <strong>Lexus B.R. </strong>(V75-2) besökte Åby förra våren och det slog verkligen gnistor om honom den dagen.<br>Vi tror att han hittar till tät i lördagens lopp och från den positionen bör han bli mycket svårslagen även om konkurrensen är tuff.</p>



<p class="wp-block-paragraph">Vi spelar för ovanlighetens skull bara med ett singelstreck och kompletterar med ett lås i Bronsdivisionen (V75-5). Antingen tror vi att <strong>Celiaz</strong> håller stången som sannolik ledare eller att <strong>Luciano Lobell </strong>löser loppet i spurten i sitt första framträdande på svensk mark. Den här hästen har vi sett fram emot att se här och förväntar oss ska kunna klättra genom klasserna.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/04/04v75.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_2024-05-04_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_2024-05-04_6_5" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<h2 class="wp-block-heading">Avd 1 – Silverdivisionen, 2.140 mter autostart</h2>



<ul class="wp-block-list">
<li><strong>Jerka Sting</strong> gjorde ett starkt lopp bakifrån på Bergsåker och fick vinna efterföljande silverförsök på Bergsåker från ledningen. Han höll ångan uppe hela vägen den dagen över lång distans och stod emot på ett smått övertygande vis. Även om han når ledningen här på nytt så tycker vi inte att uppgiften är helt enkel då han sannolikt kommer ha en klasshärdad, speedade konkurrent i rygg.</li>



<li><strong>Larry Wood</strong> är hästen vi tänker på. Han fick aldrig chansen i comebacken i förra veckan och gick i mål med &#8221;moralhöjande&#8221; krafter över målpassagen. Från innerspår finns det viss spetschans och lyckas Joakim Lövgren hålla upp den positionen kör han säkert där, men en tripp i rygg på ledaren känns väl så gångbart för Larry Wood som därtill får på sig jänkarvagn den här gången.</li>



<li><strong>Moses Boko </strong>fick aldrig vara i fred i finalen av Bronsdivisionen senast och föll med flaggan i topp. Han har fått fem veckors tävlingsfritt efter det, lär komma ut väl förberedd inför sin debut i Silverdivisionen och möter inga överdjur för sammanhanget utan bör hävda sig väl även här.</li>



<li><strong>Xanthis Hilton</strong> har tävlat på hela vintern och början av våren utan att formen avtagit. Han var stor i nederlaget senast på Romme bakom Triton och var före en sådan häst som Jerka Sting i mål. Det föreligger viss dödensrisk här om Mats E Djuse skickar iväg vilket kan göra uppgiften klart mycket tuffare även om han höll starkt från just den positionen i senaste starten.</li>



<li><strong>Crown Wise As </strong>tål att tävla på kontinuerligt och höll storstilat i lördags efter att gått i tredjespår utan rygg sista 850 meterna. Spår åtta är dock vad det är och vägen fram kan bli krävande ånyo.</li>
</ul>



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



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



<p class="wp-block-paragraph">Spetsstriden: Vi tror att Joakim Lövgren kan känna sig ganska nöjd med att ta rygg på <strong>Jerka Sting </strong>som i sin tur utmanas av <strong>Xanthis Hilton</strong>, <strong>Moses Boko</strong> och <strong>Laredo Boko</strong>.</p>



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



<ul class="wp-block-list">
<li><strong>Karaboudjan</strong> har slagit ner som en blixt på svensk mark och övertygat stort vid segerloppet. Vid triumfen på Åby näst senast avslutade hon visslande via open stretch och i försöksloppet löste hon uppgiften trots ett slutvarv i tredjespår. Denna gång är hon anmäld barfota runt om och skulle hon rentav få överta ledningen så är mycket vunnet.</li>



<li><strong>Countess Face</strong> vann från ledningen i försöksloppet och gjorde det bra utan att det för den skull slog gnistor om stoet. Vi tycker att hon är väl så bra när hon får ett rygglopp och skulle inte alls tycka att det var konstigt om Adrian Kolgjini överlämnar taktpinnen till stallkamraten i det här loppet och istället försöker utmana på speed i slutskedet, men bedömer henne även aktuell från ledningen.</li>



<li><strong>Ninetta Boko </strong>var tvåa i Oaks och ifjol samt trea i Breeders Crown-finalen. Hon fick dödens i försöksloppet vilket även var årsdebuten och höll med tanke på det ställningarna väl som tvåa bakom <strong>Xia Lloyd</strong>. Det är rimligt att tro att hon kan vara ganska så mycket förbättrad med det loppet i kroppen.</li>



<li><strong>Staro Raili </strong>fick tuff press initialt i försöksloppet och höll storstilat som tvåa. Hon drog &#8221;tåget&#8221; i tredjespår gången innan och var lika stor i nederlaget den dagen så detta sto är knalltufft. Skulle hon få en mer skonsam resa nu blir vi inte ett dugg förvånade om hon gör upp om segern.</li>



<li><strong>Kinglet Bird </strong>tog sig till final trots att det inte slog gnistor om henne i försöksloppet, men hon lär steppa upp rejält med den ögonöppnaren. Därtill blir det barfota runt om nu vilket onekligen kittlar!</li>
</ul>



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



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



<p class="wp-block-paragraph"><strong>Spetsstriden: Countess Face </strong>har god chans att passera <strong>Willa Explosive</strong> direkt och hålla ut stallkamraten <strong>Xia Lloyd</strong>. Vi bedömer<strong> Countess Face</strong> till att vara minst lika bra om inte bättre när hon får anfalla bakifrån och tycker inte att det är konstigt alls om Adrian Kolgjini skulle lämna över taktpinnen till <strong>Karaboudjan</strong>.</p>



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



<ul class="wp-block-list">
<li><strong>Lexus B.R. </strong>var på besök på Åby förra våren och övertygade stort då han sprintade undan i en 1.09-avslutning. I årsdebuten på Bjerke var det samma upplägg som gällde och femåringen var aldrig nära att tappa grepp om det loppet från ledningen. Backar vi bandet ett år tillbaka så kändes detta som en potentiell derbyhäst i Norge och nu tror vi att han hämtar igen för förlorad mark och anför från start till mål.</li>



<li><strong>Esteban Bar</strong> är en välstammad herre då han är halvbror till dubbelmiljonären Aramis Bar. Hästen har övertygat stort i två starter på svensk mark då han dels vann från dödens i Rättvik, men även via en rejäl svepning bakifrån vid triumfen på Solvalla. Hästen är finalklar för Solvallaserien den 15 maj och Björn Goop behöver inte &#8221;stressa ihjäl sig&#8221; för att jaga tät i det här loppet och vi tror han kan vara fullt nöjd med vinnarhålet. Att besegra Lexus B.R. tror vi blir tufft om det inte blir en tuff öppning, men han är i vilket fall den häst som kommer sitta tätast intill när det drar ihop sig om vi läser loppet rätt.</li>



<li><strong>Gibraltar</strong> har redan två andraplatser i Klass II från detta meeting och har gjort det jättebra. Senast gnuggade han på finfint från dödens bakom Emerald Island och nu är tanken att hästen ska få tävla med jänkarvagn för första gången någonsin.</li>



<li><strong>Quattro Håleryd </strong>höll bra från dödens bakom Cloud Busting senast på Solvalla och lyfter undan för undan. Vi tror att det finns ett par springare som helt enkelt är bättre hästar än Quattro Håleryd i det här loppet, men de får verkligen inte ha en dålig dag utan då är Quattro Håleryd tillräckligt bra för att fälla dem.</li>



<li><strong>Kjella</strong> var sexa i norska Kriteriefinalen ifjol och tycks rejält genomarbetad inför sin comeback. Vi tror dock att steget till att han ska besegra de bästa med skor och vanlig vagn i årsdebuten är väl stort att ta och rankar ner honom en bit.</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-6-8-9-11-12 <strong>C: </strong>7-10</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Innerspår är utmanande på Åby när det kommer till att få en snabb start och vi utgår ifrån att raske <strong>Lexus B.R.</strong> vinner starten.</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>Holcombe Zet </strong>kunde runda fram till ledningen efter 400 meter i uttagningsloppet och gick ifrån på ett mycket tilltalande vis i en snabb avslutning. Daniel Redén sålde av en hel del treåringar efter fjolårets mindre lyckade säsong med just den kullen, men de han behöll kan vi nog räkna oss tar stora steg i sin utveckling under året och jobbar ikapp det försprång de gav sina konkurrenter ifjol. Med två lopp i kroppen bör storformen vara nära förstående och det faktum att Örjan Kihlström medvetet valde spår ett med hästen talar för att han förväntar sig en snabbstart.</li>



<li><strong>Global Etalon </strong>skaffade sig hårdhet i Frankrike under vintern och har sett lysande ut i våras två starter på svensk mark. Han tog dödens på slutrundan i kvalet, avgjorde resolut och har god chans att hitta en position långt fram i fältet på nytt på en startsnabbhet som inte alla konkurrenter äger i det här loppet.</li>



<li><strong>Baron Tilly </strong>valde mer eller mindre att somna när starten gick senast och efter första kurvan såg det ut som att han hade startat från 20 meters tillägg. Likväl så gick hästen en häftig avslutning och hann fram till klar seger så att David Perssons balansval med barfota bak samt att köra med jänkarvagn gav effekt råder ingen tvivel om. Nu tycks man ha landat i att inte ändra något kring huvudlaget som det fanns tankar om i början av veckan, men det kan samtidigt vara ett klokt beslut för att inte riskera att hästen galopperar när han får en &#8221;ny upplevelse&#8221;.</li>



<li><strong>Pantocrator </strong>vann ett försök till Kriteriet ifjol och stod för en häftig upphämtning efter galopp i kvalet till detta lopp. Quarcio du Chene-sonen är tveklöst en av kullens mer kapabla hästar och vi räknar inte bort honom trots att han inleder längst ut bakom startbilsvingen.</li>



<li><strong>Kuiper</strong> stånkade på bra i kvalet som trea och lär gå framåt rejält med två lopp i kroppen. Nu ska han lättas från järnskor till barfota runt om och vi påstår med bestämdhet att Daniel Wäjersten har god träffprocent när han gör den typen av korrigeringar på sina hästar.</li>
</ul>



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



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



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Innerspår på Åby är smålurigt, men Örjan Kihlström valde det medvetet med <strong>Holcombe Zet</strong> och bör rimligtvis tro att han ska kunna hålla ut <strong>Call Me Gleipner</strong>, <strong>Global Etalon </strong>och <strong>King of Twilight</strong> initialt.</p>



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



<ul class="wp-block-list">
<li><strong>Celiaz</strong> tjusade den svenska publiken under fjolåret. Hon vann bland annat en Diamantstofinalen på just Åby i augusti efter att forcerats till tät från spår sex och var tvåa bakom Indy Rock i ett lopp på Sundbyholm i september. Efter att avslutat mycket starkt som fyra i vinterns första start i Paris blev det två rejäla plumpar därefter, men nu har stoet varit hemma i Italien och fått slicka såren. Som sto har hon propositionsmässig fördel i det här loppet och Alessandro Gocciadoro är inte direkt känd för att vila på hanen och ta upp från start&#8230;</li>



<li><strong>Luciano Lobell </strong>hade vi hoppats få se i Klass I-loppet den här dagen där vi förväntat oss att han skulle vara helt överlägsen och en superbra V75-spik. Nu slarvade dock kretsen kring hästen till det i matchning och tog honom över klassgränsen, men vi tror även att han kommer duga fint i Bronsdivisionen. Hästen har avslutat kring 1.11,5 sista varvet i de två senaste starterna med bra spänst hela vägen in till mål och har chans att hamna långt fram i fältet direkt om man ryggar <strong>So Far Away Ås</strong>.</li>



<li><strong>Beachcomber</strong> sköt till bra via open stretch vid senaste besöket på Åby. Den här hästen har rent allmänt lyft sig det här året och lyckas Joakim Lövgren &#8221;bara&#8221; komma ner i position med honom här så ska Beachcomber kunna vara med och slåss om tätplatserna.</li>



<li><strong>Ringo Adore</strong> togs up från start i bronsförsöket på Jägersro, backades ner i kön, men kom efter hand fram som tvåa i andraspår. Han tappade travet när det gick som fortast och galopperade 500 meter före mål utan att se trött ut i det skedet. Även om han får svårt att försvara innerspåret så har han god chans att få en spårsnål löpning vilket är guld värt på Åby.</li>



<li><strong>Danilo H.B. </strong>sköt till fullt godkänt via tredje invändigt senast på Jägersro som trea. Han står med chans på ledningen initialt, men körs knappast i den positionen i såhär pass kvalificerad omgivning.</li>
</ul>



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



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



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> <strong>Danilo H.B. </strong>har chans att hålla ut <strong>So Far Away Ås</strong> när de står sida vid sida. Utifrån lär även <strong>Icon Mearas</strong> pröva, men även om han släpps förbi så tror vi att han släpper till raska <strong>Celiaz</strong> i skede två när det är full väg och open stretch finns att tillgå.</p>



<h2 class="wp-block-heading">Avd 6 – Klass I, 2.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Charron</strong> hade en vettig treåringssäsong utan att slå ut i full blom, men av årsdebuten att döma så har han lagt i en ny växel till denna säsong. Comebackloppet blev förvisso gabnsak så lämpligt då han fick vöerta ledningen, men sättet hästen gick undan på var övertygande. Därefter har han varit struken på grund av förkylning, men är snabbt tillbaka i tävling och har fin chans att överta ledningen i tidigt skede. Då är han hästen att slå för de övriga.</li>



<li><strong>Mellby Kaliber </strong>sköt till bra från tredje invändigt över spurtrakan i försöksloppet på Bergsåker utan att hinna bli hotfull om segern. han tar steg framåt hela tiden, känns mer distansgynnad än många andra hästar i det här loppet och det behöver inte vara fel för hans del att få spara några meter på vägen genom att inleda på innerspår.</li>



<li><strong>Liberto</strong> gör sin första start på svensk mark och blir mycket intressant att följa. Vardagsloppen på Victoria Park-banan i Wolvega är stentuffa och vi tycker att han såväl gjorde det riktigt bra efter sen lucka från vinnarhålet näst senast som vid segern senast efter forcering till tät. Liberto blir att räkna med bakspåret till trots.</li>



<li><strong>Wishful Order </strong>vann i samma klass via vinnarhålet den 6 april och är finalklar. Han är tveklöst bra nog för att duga igenom om det stämmer på vägen, men vi undrar om verkligen Magnus A Djuse vågar ladda för fullt från början nu då det skulle kunna resultera i att hästen får trava i dödens vilket inte känns optimalt.</li>



<li><strong>J.S.Camaro </strong>gjorde ett bra lopp från dödens bakom Charron på Klosterskogen och höll starkt från samma position i efterföljande start i Halmstad. Får han rygg på Charron i det här loppet vilket vi tycker att mycket talar för så är han absolut stridsduglig.</li>
</ul>



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



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



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>När <strong>Wishful Order </strong>är klar för finalen och har raska hästar på insidan så tror vi inte att han tokladdas för tät. Därmed är chansen god för <strong>Charron</strong> att få överta ledningen från <strong>J.S.Camaro </strong>som vi inte tror körs i tät även lång distans.</p>



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



<ul class="wp-block-list">
<li><strong>Bengurion Jet</strong> såg himmelsk ut i uttagningsloppet på Jägersro där han sänkte Noras Beans gamla banrekord med en halv sekund. Alessandro Gocciadoro var tydlig före det loppet att han inte förväntade sig att hästen skulle vara i toppform redan nu utan ska gå framåt med varje genomkörare. Vi gillar det faktum att Bengurion Jet fått innerspår här och riskerar att bli över med ledningen. Det kan tvinga Alessandro Gocciadoro till ett lite mer avvaktande upplägg vilket bara är positivt på Åby där det är stentufft att forcera till tät och sedan stå emot elithästar. Lyckas italienaren med taktiken och serverar hästen ett fint rygglopp så tror vi att han går segrande ur striden.</li>



<li><strong>Kentucky River </strong>vann sitt uttagningslopp på ett sätt som likaså var övertygande. han fick mosa på den tunga vägen utvändigt ledaren och vi tror att Örjan Kihlström gärna tar sig fram till den positionen på nytt här så fort farten har sjunkit. Kentucky River är så pass rejäl att vi tror att han kan lösa uppgiften den vägen om andra bra hästar fått ödsla för mycket kraft initialt.</li>



<li><strong>Önas Prince</strong> var också jättefin vid sin försöksvinst då han löste uppgiften från dödens. Kommer han inte förbi Castor the Star direkt utan får forceras med full kraft för att nå ledningen så kommer det kosta en hel del kraft och då är det inte enkelt att hålla stången på Åby när det dyker upp hästar &#8221;överallt&#8221; över spurtrakan.</li>



<li><strong>Usain Töll </strong>har studsat tillbaka med besked och vi undrar om verkligen någon annan häst i det här loppet hade kunnat stå för de prestationer som denna springare har gjort i tre senaste starterna på Vincennes. Även om Usain Töll är känd som en häftig startraket så är han även effektiv bakifrån, men hans startryggar håller däremot inte allra högsta klass utan han riskerar att hamna en bit bak.</li>



<li><strong>Castor the Star </strong>såg ut att gå i mål med sparade krafter i kvalet i rygg på Mellby Jinx. Nu växlar Jörgen Westholm upp och kör barfota och låter allmänt påställd, men vi undrar om hästen verkligen orkar stå emot hela vägen om han körs i ledningen. Rygg på Önas Prince kan däremot vara rena drömupplägget&#8230;</li>



<li><strong>Beartime</strong> ska tävla barfota runt om för första gången i karriären och bara Gud vet vilken effekt det kan ge på den nio nioårige hedershästen som &#8221;aldrig&#8221; tycks göra en dålig prestation.</li>
</ul>



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



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



<p class="wp-block-paragraph"><strong>Spetsstriden: Castor the Star</strong> har toppchans att ta sig förbi <strong>Bengurion Jet</strong>. Utifrån kommer <strong>Önas Prince</strong> laddas med full kraft och ska Mats E Djuse ta emot med <strong>Castor the Star </strong>så kan det bli långt hem.</p>



<p class="wp-block-paragraph">	
				<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 4 MAJ								</h3>
														<div class="content">
								
<p class="wp-block-paragraph"><strong>Avd 1: </strong>1,2,5 (4,8)<br><strong>Avd 2: </strong>1,2,5,6,8,10 (3,11)<br><strong>Avd 3: </strong>4 Lexus B.R. (1,2)<br><strong>Avd 4: </strong>1,2,4,8,9,10 (3,5)<br><strong>Avd 5: </strong>7,10 (5,1)<br><strong>Avd 6: </strong>1,3,10 (7,2)<br><strong>Avd 7: </strong>1,2,5,7,9,10 (6,3)</p>



<p class="wp-block-paragraph"><em>3.888 rader / 1.944 kronor</em></p>
							</div>
						</div>
					</div>
				</div>
							</div>
		</div>
	
	</p>
