"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>RB CAPITAL RENDA I FUNDO DE INVESTIMENTO IMOBILIÁRIO - FII</NomeFundo>
		<CNPJFundo>08696175000197</CNPJFundo>
		<DataFuncionamento>2009-11-30</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRFIIPCTF001</CodigoISIN>
		<QtdCotasEmitidas>927162</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Híbrido</SegmentoAtuacao>
			<TipoGestao>Passiva</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>30/06</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>false</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>OLIVEIRA TRUST DTVM S.A.</NomeAdministrador>
		<CNPJAdministrador>08696175000197</CNPJAdministrador>
		<Logradouro>Avenida das Américas</Logradouro>
		<Numero>3.434</Numero>
		<Complemento>Bloco 07, sala 201</Complemento>
		<Bairro>Barra da Tijuca</Bairro>
		<Cidade>Rio de Janeiro</Cidade>
		<Estado>RJ</Estado>
		<CEP>22640-102</CEP>
		<Telefone1>(21) 3514-0000</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.oliveiratrust.com.br</Site>
		<Email>ger2.fundos@oliveiratrust.com.br</Email>
		<Competencia>2022-06-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>OLIVEIRA TRUST DTVM S.A.</Nome>
				<CNPJ>36.113.876/0001-91</CNPJ>
				<Endereco>Avenida das Américas, 3.434, bloco 07, sala 201, Barra da Tijuca - RJ</Endereco>
				<telefone>(21) 3514-0000</telefone>
			</Gestor>
			<Custodiante>
				<Nome>OLIVEIRA TRUST DTVM S.A.</Nome>
				<CNPJ>36.113.876/0001-91</CNPJ>
				<Endereco>Avenida das Américas, 3.434, bloco 07, sala 201, Barra da Tijuca - RJ</Endereco>
				<telefone>(21) 3514-0000</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>Grant Thornton Auditores Independentes</Nome>
				<CNPJ>10.830.108/0001-46</CNPJ>
				<Endereco>Rua Voluntários da Pátria 89, salas 101 e 102 - Botafogo/RJ CEP: 22270-000</Endereco>
				<telefone>(11) 3886-4800</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</DistribuidorCotas>
			<ConsultorEspecializado>
				<Nome>RB CAPITAL REALTY INVESTIMENTOS IMOBILIÁRIOS LTDA.</Nome>
				<CNPJ>11.426.501/0001-50</CNPJ>
				<Endereco>Cidade de São Paulo Estado de São Paulo, na Avenida Brigadeiro Faria Lima, nº 4440, 11º andar, Itaim Bibi</Endereco>
				<telefone>(11) 3127-2700</telefone>
			</ConsultorEspecializado>
			<EmpEspecializadaAdmLocacoes>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</EmpEspecializadaAdmLocacoes>
			<OutrosPrestadores>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>O fundo não tem programação para novos investimentos no momento.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>Ao final dos últimos 12 meses (base junho/22) o FII distribuiu o montante total de R$ 15,48 por cota, atingindo uma rentabilidade de 8,00% no período de 12 meses (com relação a cota patrimonial de fechamento de  jul/2021). 
</ResultadoFundo>
			<ConjunturaEconomica>Apesar dos desdobramentos causados pela crise do COVID-19 na economia mundial os os imóveis presentes na carteira do Fundo RB CAPITAL RENDA I FII estão 100% ocupados e voltados em sua maioria para as atividades de estocagem de produtos e materiais, ramo da economia que tem sofrido um impacto consideravelmente menor diante da crise atual. </ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Ao longo do último ano foi possível observar um signifcativo arrefecimento da pandemia no país, mediante ao sucesso da campanha de vacinação. A expectativa é de que os efeitos negativos da pandemia na economia diminuam cada vez mais na medida em que a doença vem perdendo força.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Galpão  / Ambev / RUA ALFREDO PINTO Nº 91 - SÃO JOSÉ DOS PINHAIS – PR</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>25536000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0319939347990902</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Galpão  / Barry / RUA “A” , QUADRA “D” LOTES  11, 12 E 13 - ILHÉUS – BA</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>10227000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.241489282800564</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Loja no Shopping Metrô Tatuapé - SP / C&amp;A / RUA DR. MELLO FREIRE S/N - SÃO PAULO – SP</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>14986000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0518190446061373</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Galpão  / Danfoss / RUA JOÃO FURLAN, S/Nº - OSASCO – SP</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>38248000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0961124896608767</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Loja  / Pernambucanas Nova Iguaçu / AVENIDA NILO PEÇANHA Nº 296, ESQUINA COM A VIA LIGHT - NOVA IGUAÇU – RJ</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>28545000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0265320737987246</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Galpão  / Astuti / AV. RONAT WALTER SODRE, Nº 2.800 - IBIPORÃ - PR</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>24693000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0304303439610492</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Misto / Telha Norte / AVENIDA GENERAL DAVID  -SARNOFF, Nº 4.840 - CONTAGEM – MG</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>23695000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0485846215619353</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Laudo de valor emitido por empresa independente e especilizada do setor. A finalidade da avaliação, leva em conta a natureza do imóvel avaliando, sua situação geo-sócio-econômica e a disponibilidade de dados e evidêncas de mercado seguras, foi optado dos os criterios de avaliaçao de usar o "Método da Renda" na sua variante de Valor Econômico por Fluxo de Caixa Descontado, para a definição dos valores referenciais e indicadores. Também foram utilizados o Método Comparativo para a determinação de valores parciais de avaliação, como por exemplo o valor locativo e o Evolutivo (Custo) para a aferição de resultados referenciais.                                                                                                                                                                                                                                                                                                                                                                     ESPECIFICAÇÃO DA AVALIAÇÃO
Como as avaliações foram fundamentadas principalmente pelo "Método da Renda" na sua variante de Valor Econômico por Fluxo de Caixa Descontado, analisamos a especificação das avaliações de acordo com o item 10 da NBR 14653-4, que define que o laudo deve ser enquadrado em graus I, II ou III quanto à fundamentação. O laudo emitido foi classificado como "Grau II", conforme o que dispõem as normas da ABNT.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos>não aplicável.</AnaliseImpactos>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Avenida das Américas, 3.434, bloco 7, sala 201, Barra da Tijuca, Rio de Janeiro - RJ</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>ger2.fundos@oliveiratrust.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>As solicitações dos itens (i) e (ii) podem ser direcionadas diretamente para  e-mail da equipe de Administração, qual seja, ger2.fundos@oliveiratrust.com.br ou ainda pelo "Fale Conosco" disponível no portal do administrador pelo link a seguir: http://www.oliveiratrust.com.br/portal/?item1=Atendimento&amp;item2=Fale_Conosco</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Somente poderão votar na Assembleia Geral os cotistas inscritos no registro de cotistas na data da convocação da assembleia, seus representantes legais ou procuradores legalmente constituídos há menos de 1 (um) ano.Os cotistas também poderão votar por meio de comunicação escrita ou eletrônica, observado o disposto neste Regulamento e a legislação e normativos vigentes. As deliberações da Assembleia Geral poderão ser tomadas, independentemente de convocação, mediante processo de consulta, formalizada por carta, correio eletrônico ou telegrama dirigido pelo ADMINISTRADOR aos cotistas, para resposta no prazo de 30 (trinta) dias, devendo constar da consulta todos os elementos informativos necessários ao exercício de voto.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Não há previsão no regulamento.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>O ADMINISTRADOR, a partir de 1º de agosto de 2009, terá direito a receber, a título de Taxa de Administração, valor correspondente ao somatório de (i) R$ 9.400,00 (nove mil e quatrocentos reais) mensais; e (ii) o valor calculado com base na tabela do Anexo I deste Regulamento, referente à atividade de escrituração das Cotas (“Taxa de Administração”).</PoliticaRemuneracao>
			<ValorPagoAno>303232.28</ValorPagoAno>
			<PercentPatrimonioContabil>0.0018</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.0021</PercentPatrimonioValorMercado>
		</RemuneracaoAdministrador>
		<Governanca>
			<RepresentantesCotistas>
				<Representante1>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal xsi:nil="true"/>
						<CondenacaoProcAdminCVM xsi:nil="true"/>
					</Eventos>
				</Representante1>
				<Representante2>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante2>
				<Representante3>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante3>
				<Representante4>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante4>
				<Representante5>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante5>
			</RepresentantesCotistas>
			<DiretorResponsavel>
				<Nome>José Alexandre Costa de Freitas</Nome>
				<Idade>46</Idade>
				<CPF>008.991.207-17</CPF>
				<Email>ger2.fundos@oliveiratrust.com.br</Email>
				<Profissao>Diretor Presidente</Profissao>
				<FormacaoAcademica>Direito</FormacaoAcademica>
				<DataInicioFuncao>2014-03-05</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Oliveira Trust</NomeEmpresa>
						<Periodo>Março/1992 - Data Atual</Periodo>
						<CargoFuncoes>Diretor Presidente</CargoFuncoes>
						<AtividadePrincipalEmpresa>Distribuidora de Títulos e Valores Mobiliários</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>Não</CondenacaoCriminal>
					<CondenacaoProcAdminCVM>Não</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="8360" numCotasDetidas="927162" percDetidoRelTotal="1" percDetidoPF="0.9587" percDetidoPJ="0.0413"/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>São considerados relevantes pelo Administrador qualquer deliberação da assembleia geral de cotistas ou do Administrador ou qualquer outro ato ou fato que possa influir de modo ponderável (I) na cotação das cotas ou de valores mobiliários a elas referenciados, (II) na decisão dos investidores de comprar, vender ou manter as cotas, e (III) na decisão dos investidores de exercer quaisquer direitos inerentes à condição de titular cotas ou de valores mobiliários a elas referenciados, tais como, exemplificativamente, mas não limitados a: I – atraso para o recebimento de quaisquer rendimentos que representem percentual significativo dentre as receitas do fundo; II – venda ou locação dos imóveis de propriedade do fundo destinados a arrendamento ou locação, e que possam gerar impacto significativo em sua rentabilidade; III – fusão, incorporação, cisão, transformação do fundo ou qualquer outra operação que altere substancialmente a sua composição patrimonial; IV – emissão de cotas nos termos do inciso VIII do artigo 15 da Instrução CVM 472. Tais informações são divulgadas à CVM, à BM&amp;FBovespa, e também através do site do Administrador, no endereço https://www.oliveratrust.com.br/. Adicionalmente, o Administrador adota segregação física da sua área de administração de fundos imobiliários em relação às áreas responsáveis por outras atividades e linhas de negócio. Neste sentido, o acesso a sistemas e arquivos, inclusive em relação à guarda de documentos de caráter confidencial, é restrito à equipe dedicada pela administração de tais fundos, sendo possível o compartilhamento de informações às equipes jurídicas e de compliance que atendam tal área de negócio. Adicionalmente, o Administrador tem como política interna a exigência de termos de confidencialidade com todos os seus funcionários, no momento de sua contratação.</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>Fundo listado em bolsa de valores (BM&amp;FBovespa), onde suas cotas são admitidas à negociação no mercado secundário. As informações e documentos públicos do fundo estão disponíveis no website do Administrador: https://www.oliveratrust.com.br</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>https://www.oliveiratrust.com.br/downloads/OLIVEIRA_TRUST_Politica_de_Voto.pdf</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>N/A</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>N/A</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"